Fix leaking error when comparison leads to TypeError

2026-01-01 15:55:40 +03:00 · 2017-01-16 12:26:19 -05:00
145 changed files with 2450 additions and 6163 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,17 +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:
-  TargetRubyVersion: 2.4
  Exclude:
-    - 'vendor/bundle/**/*'
+    - 'performance/shopify/*'
+    - 'pkg/**'

-Naming/MethodName:
+Metrics/BlockNesting:
+  Max: 3
  Exclude:
-    - 'example/server/liquid_servlet.rb'
+    - 'lib/liquid/block_body.rb'
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Lint/AssignmentInCondition:
+  Enabled: false
+
+Lint/AmbiguousOperator:
+  Enabled: false
+
+Lint/AmbiguousRegexpLiteral:
+  Enabled: false
+
+Lint/ParenthesesAsGroupedExpression:
+  Enabled: false
+
+Lint/UnusedBlockArgument:
+  Enabled: false
+
+Lint/EndAlignment:
+  AlignWith: variable
+
+Lint/UnusedMethodArgument:
+  Enabled: false
+
+Style/SingleLineBlockParams:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/StringLiteralsInInterpolation:
+  Enabled: false
+
+Style/AndOr:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/BracesAroundHashParameters:
+  Enabled: false
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/SpaceInsideBrackets:
+  Enabled: false
+
+Style/SpaceBeforeBlockBraces:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/TrailingComma:
+  Enabled: false
+
+Style/IndentHash:
+  EnforcedStyle: consistent
+
+Style/FormatString:
+  Enabled: false
+
+Style/AlignParameters:
+  EnforcedStyle: with_fixed_indentation
+
+Style/MultilineOperationIndentation:
+  EnforcedStyle: indented
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/RaiseArgs:
+  Enabled: false
+
+Style/DeprecatedHashMethods:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/SymbolLiteral:
+  Enabled: false
+
+Performance/Count:
+  Enabled: false
+
+Style/ConstantName:
+  Enabled: false
+
+Style/CaseIndentation:
+  Enabled: false
+
+Style/ClassVars:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/TrivialAccessors:
+  AllowPredicates: true
+
+Style/WordArray:
+  Enabled: false
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -1,48 +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
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: runtime_error, standard_error
-Lint/InheritException:
-  Exclude:
-    - 'lib/liquid/interrupts.rb'
+# Offense count: 5
+Lint/NestedMethodDefinition:
+  Enabled: false

-# Offense count: 98
-# Cop supports --auto-correct.
-# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
-# URISchemes: http, https
-Layout/LineLength:
+# Offense count: 53
+Metrics/AbcSize:
+  Max: 58
+
+# Offense count: 12
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+# Offense count: 553
+# Configuration parameters: AllowURI, URISchemes.
+Metrics/LineLength:
  Max: 294

-# Offense count: 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
+Style/AccessorMethodName:
+  Enabled: false
+
+# Offense count: 1
+# Cop supports --auto-correct.
+Style/ClosingParenthesisIndentation:
+  Enabled: false
+
+# Offense count: 3
+# Configuration parameters: MinBodyLength.
+Style/GuardClause:
+  Enabled: false
+
+# Offense count: 4
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+Style/MethodName:
+  Enabled: false
+
+# Offense count: 1
+Style/MultilineBlockChain:
+  Enabled: false
+
+# Offense count: 2
+# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
+Style/Next:
+  Enabled: false
+
+# Offense count: 7
+# Cop supports --auto-correct.
+# Configuration parameters: AllowAsExpressionSeparator.
+Style/Semicolon:
+  Enabled: false
+
+# Offense count: 1
+# Cop supports --auto-correct.
+# Configuration parameters: MaxLineLength.
+Style/WhileUntilModifier:
+  Enabled: false
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,26 +1,25 @@
 language: ruby
-cache: bundler

 rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-  - &latest_ruby 2.7
+  - 2.1
+  - 2.2
+  - 2.3.3
  - ruby-head
+  - jruby-head
+#  - 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

-branches:
-  only:
-    - master
-    - gh-pages
-    - /.*-stable/
+script: "bundle exec rake"

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

 gemspec
-
-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.78.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: 'bd53db95de3d44d631e7c5a267c3d934e66107dd'
  end
 end
--- a/History.md
+++ b/History.md
@@ -1,64 +1,5 @@
 # Liquid Change Log

-### Unreleased
-
-* Split Strainer class as a factory and a template (#1208) [Thierry Joyal]
-* Remove handling of a nil context in the Strainer class (#1218) [Thierry Joyal]
-* StaticRegisters#fetch to raise on missing key (#1250) [Thierry Joyal]
-
-## 4.0.3 / 2019-03-12
-
-### Fixed
-* Fix break and continue tags inside included templates in loops (#1072) [Justin Li]
-
-## 4.0.2 / 2019-03-08
-
-### Changed
-* Add `where` filter (#1026) [Samuel Doiron]
-* Add `ParseTreeVisitor` to iterate the Liquid AST (#1025) [Stephen Paul Weber]
-* Improve `strip_html` performance (#1032) [printercu]
-
-### Fixed
-* Add error checking for invalid combinations of inputs to sort, sort_natural, where, uniq, map, compact filters (#1059) [Garland Zhang]
-* Validate the character encoding in url_decode (#1070) [Clayton Smith]
-
-## 4.0.1 / 2018-10-09
-
-### Changed
-* Add benchmark group in Gemfile (#855) [Jerry Liu]
-* Allow benchmarks to benchmark render by itself (#851) [Jerry Liu]
-* Avoid calling `line_number` on String node when rescuing a render error. (#860) [Dylan Thacker-Smith]
-* Avoid duck typing to detect whether to call render on a node. [Dylan Thacker-Smith]
-* Clarify spelling of `reversed` on `for` block tag (#843) [Mark Crossfield]
-* Replace recursion with loop to avoid potential stack overflow from malicious input (#891, #892) [Dylan Thacker-Smith]
-* Limit block tag nesting to 100 (#894) [Dylan Thacker-Smith]
-* Replace `assert_equal nil` with `assert_nil` (#895) [Dylan Thacker-Smith]
-* Remove Spy Gem (#896) [Dylan Thacker-Smith]
-* Add `collection_name` and `variable_name` reader to `For` block (#909)
-* Symbols render as strings (#920) [Justin Li]
-* Remove default value from Hash objects (#932) [Maxime Bedard]
-* Remove one level of nesting (#944) [Dylan Thacker-Smith]
-* Update Rubocop version (#952) [Justin Li]
-* Add `at_least` and `at_most` filters (#954, #958) [Nithin Bekal]
-* Add a regression test for a liquid-c trim mode bug (#972) [Dylan Thacker-Smith]
-* Use https rather than git protocol to fetch liquid-c [Dylan Thacker-Smith]
-* Add tests against Ruby 2.4 (#963) and 2.5 (#981)
-* Replace RegExp literals with constants (#988) [Ashwin Maroli]
-* Replace unnecessary `#each_with_index` with `#each` (#992) [Ashwin Maroli]
-* Improve the unexpected end delimiter message for block tags. (#1003) [Dylan Thacker-Smith]
-* Refactor and optimize rendering (#1005) [Christopher Aue]
-* Add installation instruction (#1006) [Ben Gift]
-* Remove Circle CI (#1010)
-* Rename deprecated `BigDecimal.new` to `BigDecimal` (#1024) [Koichi ITO]
-* Rename deprecated Rubocop name (#1027) [Justin Li]
-
-### Fixed
-* Handle `join` filter on non String joiners (#857) [Richard Monette]
-* Fix duplicate inclusion condition logic error of `Liquid::Strainer.add_filter` method (#861)
-* Fix `escape`, `url_encode`, `url_decode` not handling non-string values (#898) [Thierry Joyal]
-* Fix raise when variable is defined but nil when using `strict_variables` [Pascal Betz]
-* Fix `sort` and `sort_natural` to handle arrays with nils (#930) [Eric Chan]
-
 ## 4.0.0 / 2016-12-14 / branch "4-0-stable"

 ### Changed
@@ -79,13 +20,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/35
+++ b/35
@@ -1,33 +1,29 @@
-# frozen_string_literal: true
-
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"

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

-desc('run test suite with default parser')
+desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
  t.libs << '.' << 'lib' << 'test'
  t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
-  t.verbose    = false
+  t.verbose = false
 end

-desc('run test suite with warn error mode')
+desc 'run test suite with warn error mode'
 task :warn_test do
  ENV['LIQUID_PARSER_MODE'] = 'warn'
  Rake::Task['base_test'].invoke
 end

 task :rubocop do
-  if RUBY_ENGINE == 'ruby'
-    require 'rubocop/rake_task'
-    RuboCop::RakeTask.new
-  end
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
 end

-desc('runs test suite with both strict and lax parsers')
+desc 'runs test suite with both strict and lax parsers'
 task :test do
  ENV['LIQUID_PARSER_MODE'] = 'lax'
  Rake::Task['base_test'].invoke
@@ -36,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
@@ -49,7 +45,7 @@ task :test do
  end
 end

-task(gem: :build)
+task gem: :build
 task :build do
  system "gem build liquid.gemspec"
 end
@@ -89,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.1
--- a/example/server/example_servlet.rb
+++ b/example/server/example_servlet.rb
@@ -1,8 +1,6 @@
-# frozen_string_literal: true
-
 module ProductsFilter
  def price(integer)
-    format("$%.2d USD", integer / 100.0)
+    sprintf("$%.2d USD", integer / 100.0)
  end

  def prettyprint(text)
--- a/example/server/liquid_servlet.rb
+++ b/example/server/liquid_servlet.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
  def do_GET(req, res)
    handle(:get, req, res)
@@ -11,17 +9,17 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet

  private

-  def handle(_type, req, res)
-    @request  = req
+  def handle(type, req, res)
+    @request = req
    @response = res

    @request.path_info =~ /(\w+)\z/
-    @action  = Regexp.last_match(1) || 'index'
+    @action = $1 || 'index'
    @assigns = send(@action) if respond_to?(@action)

    @response['Content-Type'] = "text/html"
    @response.status = 200
-    @response.body   = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
+    @response.body = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
  end

  def read_template(filename = @action)
--- a/example/server/server.rb
+++ b/example/server/server.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'webrick'
 require 'rexml/document'

@@ -10,5 +8,5 @@ require_relative 'example_servlet'
 # Setup webrick
 server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
 server.mount('/', Servlet)
-trap("INT") { server.shutdown }
+trap("INT"){ server.shutdown }
 server.start
--- a/lib/liquid.rb
+++ b/lib/liquid.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # Copyright (c) 2005 Tobias Luetke
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -23,10 +21,10 @@

 module Liquid
  FilterSeparator             = /\|/
-  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'
-  WhitespaceControl           = '-'
+  ArgumentSeparator           = ','.freeze
+  FilterArgumentSeparator     = ':'.freeze
+  VariableAttributeSeparator  = '.'.freeze
+  WhitespaceControl           = '-'.freeze
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -47,7 +45,6 @@ module Liquid
 end

 require "liquid/version"
-require 'liquid/parse_tree_visitor'
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
@@ -57,14 +54,11 @@ require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer_factory'
-require 'liquid/strainer_template'
+require 'liquid/strainer'
 require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
-require 'liquid/tag/disabler'
-require 'liquid/tag/disableable'
 require 'liquid/block'
 require 'liquid/block_body'
 require 'liquid/document'
@@ -79,11 +73,6 @@ require 'liquid/condition'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
-require 'liquid/partial_cache'
-require 'liquid/usage'
-require 'liquid/register'
-require 'liquid/static_registers'
-require 'liquid/template_factory'

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

    def parse(tokens)
      @body = BlockBody.new
@@ -10,31 +11,29 @@ module Liquid
      end
    end

-    # For backwards compatibility
    def render(context)
      @body.render(context)
    end

+    def blank?
+      @blank
+    end
+
    def nodelist
      @body.nodelist
    end

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

@@ -49,23 +48,17 @@ module Liquid
    protected

    def parse_body(body, tokens)
-      if parse_context.depth >= MAX_DEPTH
-        raise StackLevelError, "Nesting too deep"
-      end
-      parse_context.depth += 1
-      begin
-        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
-          return false if end_tag_name == block_delimiter
-          unless end_tag_name
-            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
-          end
+      body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
+        @blank &&= body.blank?

-          # 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,114 +1,52 @@
-# frozen_string_literal: true
-
-require 'English'
-
 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/
-    TAGSTART            = "{%"
-    VARSTART            = "{{"
+    FullToken = /\A#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    TAGSTART = "{%".freeze
+    VARSTART = "{{".freeze

    attr_reader :nodelist

    def initialize
      @nodelist = []
-      @blank    = true
+      @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
+      while token = tokenizer.shift
+        unless token.empty?
+          case
+          when token.start_with?(TAGSTART)
+            whitespace_handler(token, parse_context)
+            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)
+            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 =~ /\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
-
-      yield nil, nil
-    end
-
-    # @api private
-    def self.unknown_tag_in_liquid_tag(tag, parse_context)
-      Block.raise_unknown_tag(tag, 'liquid', '%}', parse_context)
-    end
-
-    private def parse_liquid_tag(markup, parse_context)
-      liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
-      parse_for_liquid_tag(liquid_tag_tokenizer, parse_context) do |end_tag_name, _end_tag_markup|
-        if end_tag_name
-          BlockBody.unknown_tag_in_liquid_tag(end_tag_name, parse_context)
-        end
-      end
-    end
-
-    private def parse_for_document(tokenizer, parse_context)
-      while (token = tokenizer.shift)
-        next if token.empty?
-        case
-        when token.start_with?(TAGSTART)
-          whitespace_handler(token, parse_context)
-          unless token =~ FullToken
-            raise_missing_tag_terminator(token, parse_context)
-          end
-          tag_name = Regexp.last_match(2)
-          markup   = Regexp.last_match(4)
-
-          if parse_context.line_number
-            # newlines inside the tag should increase the line number,
-            # particularly important for multiline {% liquid %} tags
-            parse_context.line_number += Regexp.last_match(1).count("\n") + Regexp.last_match(3).count("\n")
-          end
-
-          if tag_name == 'liquid'
-            parse_liquid_tag(markup, parse_context)
-            next
-          end
-
-          unless (tag = registered_tags[tag_name])
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          end
-          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-          @blank &&= new_tag.blank?
-          @nodelist << new_tag
-        when token.start_with?(VARSTART)
-          whitespace_handler(token, parse_context)
-          @nodelist << create_variable(token, parse_context)
-          @blank = false
-        else
-          if parse_context.trim_whitespace
-            token.lstrip!
-          end
-          parse_context.trim_whitespace = false
-          @nodelist << token
-          @blank &&= !!(token =~ WhitespaceOrNothing)
        end
        parse_context.line_number = tokenizer.line_number
      end
@@ -119,7 +57,7 @@ module Liquid
    def whitespace_handler(token, parse_context)
      if token[2] == WhitespaceControl
        previous_token = @nodelist.last
-        if previous_token.is_a?(String)
+        if previous_token.is_a? String
          previous_token.rstrip!
        end
      end
@@ -130,69 +68,52 @@ module Liquid
      @blank
    end

-    # Remove blank strings in the block body for a control flow tag (e.g. `if`, `for`, `case`, `unless`)
-    # with a blank body.
-    #
-    # For example, in a conditional assignment like the following
-    #
-    # ```
-    # {% if size > max_size %}
-    #   {% assign size = max_size %}
-    # {% endif %}
-    # ```
-    #
-    # we assume the intention wasn't to output the blank spaces in the `if` tag's block body, so this method
-    # will remove them to reduce the render output size.
-    #
-    # Note that it is now preferred to use the `liquid` tag for this use case.
-    def remove_blank_strings
-      raise "remove_blank_strings only support being called on a blank block body" unless @blank
-      @nodelist.reject! { |node| node.instance_of?(String) }
-    end
-
    def render(context)
-      render_to_output_buffer(context, +'')
-    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?

-        if node.instance_of?(String)
-          output << node
-        else
-          render_node(context, output, node)
+        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 %}. These tags may also occur through Block or Include tags.
-          break if context.interrupt? # might have happened in a for-block
-        end
-        idx += 1
+          # or {% continue %}
+          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, token.raw)
+          output << nil
+        rescue ::StandardError => e
+          output << context.handle_error(e, token.line_number, token.raw)
+        end
      end

-      output
+      output.join
    end

    private

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

-    def raise_if_resource_limits_reached(context, length)
-      context.resource_limits.render_length += length
-      return unless context.resource_limits.reached?
-      raise MemoryError, "Memory limits exceeded"
+      context.resource_limits.render_length += node_output.length
+      if context.resource_limits.reached?
+        raise MemoryError.new("Memory limits exceeded".freeze)
+      end
+      node_output
    end

    def create_variable(token, parse_context)
@@ -204,11 +125,11 @@ module Liquid
    end

    def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: 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", 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
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Container for liquid nodes which conveniently wraps decision making logic
  #
@@ -10,65 +8,58 @@ module Liquid
  #
  class Condition #:nodoc:
    @@operators = {
-      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
-      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<' => :<,
-      '>' => :>,
-      '>=' => :>=,
-      '<=' => :<=,
-      'contains' => lambda do |_cond, left, right|
+      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<'.freeze  => :<,
+      '>'.freeze  => :>,
+      '>='.freeze => :>=,
+      '<='.freeze => :<=,
+      'contains'.freeze => lambda do |cond, left, right|
        if left && right && left.respond_to?(:include?)
          right = right.to_s if left.is_a?(String)
          left.include?(right)
        else
          false
        end
-      end,
+      end
    }

    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
+      @left = left
      @operator = operator
-      @right    = right
-
+      @right = right
      @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)
-      @child_relation  = :or
+      @child_relation = :or
      @child_condition = condition
    end

    def and(condition)
-      @child_relation  = :and
+      @child_relation = :and
      @child_condition = condition
    end

@@ -81,13 +72,9 @@ module Liquid
    end

    def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
    end

-    protected
-
-    attr_reader :child_relation
-
    private

    def equal_variables(left, right)
@@ -116,30 +103,21 @@ module Liquid
      # return this as the result.
      return context.evaluate(left) if op.nil?

-      left  = context.evaluate(left)
+      left = context.evaluate(left)
      right = context.evaluate(right)

-      operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
+      operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))

      if operation.respond_to?(:call)
        operation.call(self, left, right)
-      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
+      elsif left.respond_to?(operation) && right.respond_to?(operation)
        begin
          left.send(operation, right)
-        rescue ::ArgumentError => e
-          raise Liquid::ArgumentError, e.message
+        rescue ::ArgumentError, TypeError => e
+          raise Liquid::ArgumentError.new(e.message)
        end
      end
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.left, @node.right,
-          @node.child_condition, @node.attachment
-        ].compact
-      end
-    end
  end

  class ElseCondition < Condition
--- a/lib/liquid/context.rb
+++ b/lib/liquid/context.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Context keeps the variable stack and resolves variables, as well as keywords
  #
@@ -14,46 +12,37 @@ module Liquid
  #
  #   context['bob']  #=> nil  class Context
  class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters

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

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

-      @interrupts    = []
-      @filters       = []
+      @interrupts = []
+      @filters = []
      @global_filter = nil
-      @disabled_tags = {}
    end
-    # rubocop:enable Metrics/ParameterLists

    def warnings
      @warnings ||= []
    end

    def strainer
-      @strainer ||= StrainerFactory.create(self, @filters)
+      @strainer ||= Strainer.create(self, @filters)
    end

    # Adds filters to this context.
@@ -85,10 +74,10 @@ module Liquid
      @interrupts.pop
    end

-    def handle_error(e, line_number = nil)
+    def handle_error(e, line_number = nil, raw_token = nil)
      e = internal_error unless e.is_a?(Liquid::Error)
      e.template_name ||= template_name
-      e.line_number   ||= line_number
+      e.line_number ||= line_number
      errors.push(e)
      exception_renderer.call(e).to_s
    end
@@ -100,7 +89,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
@@ -122,31 +111,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,
-        registers: StaticRegisters.new(registers)
-      ).tap do |subcontext|
-        subcontext.base_scope_depth   = base_scope_depth + 1
-        subcontext.exception_renderer = exception_renderer
-        subcontext.filters  = @filters
-        subcontext.strainer = nil
-        subcontext.errors   = errors
-        subcontext.warnings = warnings
-        subcontext.disabled_tags = @disabled_tags
-      end
+      pop if @this_stack_used
+      @this_stack_used = old_stack_used
    end

    def clear_instance_assigns
@@ -155,6 +132,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

@@ -179,84 +160,49 @@ 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

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

      variable
    end

-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
-      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

-    def with_disabled_tags(tag_names)
-      tag_names.each do |name|
-        @disabled_tags[name] = @disabled_tags.fetch(name, 0) + 1
-      end
-      yield
-    ensure
-      tag_names.each do |name|
-        @disabled_tags[name] -= 1
-      end
-    end
-
-    def tag_disabled?(tag_name)
-      @disabled_tags.fetch(tag_name, 0) > 0
-    end
-
-    protected
-
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
-
    private

-    attr_reader :base_scope_depth
-
-    def try_variable_find_in_environments(key, raise_on_not_found:)
-      @environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
-      end
-      @static_environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
-      end
-      nil
-    end
-
-    def check_overflow
-      raise StackLevelError, "Nesting too deep" if overflow?
-    end
-
-    def overflow?
-      base_scope_depth + @scopes.length > Block::MAX_DEPTH
-    end
-
    def internal_error
      # raise and catch to set backtrace and cause on exception
      raise Liquid::InternalError, 'internal'
--- a/lib/liquid/document.rb
+++ b/lib/liquid/document.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Document < BlockBody
    def self.parse(tokens, parse_context)
@@ -9,7 +7,7 @@ module Liquid
    end

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

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

 module Liquid
@@ -27,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

@@ -69,7 +67,7 @@ module Liquid

        if include?(Enumerable)
          blacklist += Enumerable.public_instance_methods
-          blacklist -= [:sort, :count, :first, :min, :max]
+          blacklist -= [:sort, :count, :first, :min, :max, :include?]
        end

        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
--- a/lib/liquid/errors.rb
+++ b/lib/liquid/errors.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Error < ::StandardError
    attr_accessor :line_number
@@ -7,7 +5,7 @@ module Liquid
    attr_accessor :markup_context

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

@@ -22,11 +20,11 @@ module Liquid
    private

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

      if line_number
@@ -40,19 +38,19 @@ module Liquid
    end
  end

-  ArgumentError       = Class.new(Error)
-  ContextError        = Class.new(Error)
-  FileSystemError     = Class.new(Error)
-  StandardError       = Class.new(Error)
-  SyntaxError         = Class.new(Error)
-  StackLevelError     = Class.new(Error)
-  MemoryError         = Class.new(Error)
-  ZeroDivisionError   = Class.new(Error)
-  FloatDomainError    = Class.new(Error)
-  UndefinedVariable   = Class.new(Error)
+  ArgumentError = Class.new(Error)
+  ContextError = Class.new(Error)
+  FileSystemError = Class.new(Error)
+  StandardError = Class.new(Error)
+  SyntaxError = Class.new(Error)
+  StackLevelError = Class.new(Error)
+  TaintedError = Class.new(Error)
+  MemoryError = Class.new(Error)
+  ZeroDivisionError = Class.new(Error)
+  FloatDomainError = Class.new(Error)
+  UndefinedVariable = Class.new(Error)
  UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter     = Class.new(Error)
+  UndefinedFilter = Class.new(Error)
  MethodOverrideError = Class.new(Error)
-  DisabledError       = Class.new(Error)
-  InternalError       = Class.new(Error)
+  InternalError = Class.new(Error)
 end
--- a/lib/liquid/expression.rb
+++ b/lib/liquid/expression.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Expression
    class MethodLiteral
@@ -16,32 +14,28 @@ module Liquid
    end

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

    def self.parse(markup)
      if LITERALS.key?(markup)
        LITERALS[markup]
      else
        case markup
-        when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
-          Regexp.last_match(1)
-        when INTEGERS_REGEX
-          Regexp.last_match(1).to_i
-        when RANGES_REGEX
-          RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
-        when FLOATS_REGEX
-          Regexp.last_match(1).to_f
+        when /\A'(.*)'\z/m # Single quoted strings
+          $1
+        when /\A"(.*)"\z/m # Double quoted strings
+          $1
+        when /\A(-?\d+)\z/ # Integer and floats
+          $1.to_i
+        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+          RangeLookup.parse($1, $2)
+        when /\A(-?\d[\d\.]+)\z/ # Floats
+          $1.to_f
        else
          VariableLookup.parse(markup)
        end
--- a/lib/liquid/extensions.rb
+++ b/lib/liquid/extensions.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'time'
 require 'date'

@@ -9,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
--- a/lib/liquid/file_system.rb
+++ b/lib/liquid/file_system.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag.
  #
@@ -46,8 +44,8 @@ module Liquid
  class LocalFileSystem
    attr_accessor :root

-    def initialize(root, pattern = "_%s.liquid")
-      @root    = root
+    def initialize(root, pattern = "_%s.liquid".freeze)
+      @root = root
      @pattern = pattern
    end

@@ -59,9 +57,9 @@ module Liquid
    end

    def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless %r{\A[^./][a-zA-Z0-9_/]+\z}.match?(template_path)
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/

-      full_path = if template_path.include?('/')
+      full_path = if template_path.include?('/'.freeze)
        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
      else
        File.join(root, @pattern % template_path)
--- a/lib/liquid/forloop_drop.rb
+++ b/lib/liquid/forloop_drop.rb
@@ -1,12 +1,10 @@
-# frozen_string_literal: true
-
 module Liquid
  class ForloopDrop < Drop
    def initialize(name, length, parentloop)
-      @name       = name
-      @length     = length
+      @name = name
+      @length = length
      @parentloop = parentloop
-      @index      = 0
+      @index = 0
    end

    attr_reader :name, :length, :parentloop
--- a/lib/liquid/i18n.rb
+++ b/lib/liquid/i18n.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'yaml'

 module Liquid
@@ -28,13 +26,13 @@ module Liquid
    def interpolate(name, vars)
      name.gsub(/%\{(\w+)\}/) do
        # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        (vars[Regexp.last_match(1).to_sym]).to_s
+        "#{vars[$1.to_sym]}"
      end
    end

    def deep_fetch_translation(name)
-      name.split('.').reduce(locale) do |level, cur|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+      name.split('.'.freeze).reduce(locale) do |level, cur|
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
      end
    end
  end
--- a/lib/liquid/interrupts.rb
+++ b/lib/liquid/interrupts.rb
@@ -1,12 +1,10 @@
-# frozen_string_literal: true
-
 module Liquid
  # An interrupt is any command that breaks processing of a block (ex: a for loop).
  class Interrupt
    attr_reader :message

    def initialize(message = nil)
-      @message = message || "interrupt"
+      @message = message || "interrupt".freeze
    end
  end

--- a/lib/liquid/lexer.rb
+++ b/lib/liquid/lexer.rb
@@ -1,53 +1,44 @@
-# frozen_string_literal: true
-
 require "strscan"
 module Liquid
  class Lexer
    SPECIALS = {
-      '|' => :pipe,
-      '.' => :dot,
-      ':' => :colon,
-      ',' => :comma,
-      '[' => :open_square,
-      ']' => :close_square,
-      '(' => :open_round,
-      ')' => :close_round,
-      '?' => :question,
-      '-' => :dash,
-    }.freeze
-    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
+      '|'.freeze => :pipe,
+      '.'.freeze => :dot,
+      ':'.freeze => :colon,
+      ','.freeze => :comma,
+      '['.freeze => :open_square,
+      ']'.freeze => :close_square,
+      '('.freeze => :open_round,
+      ')'.freeze => :close_round,
+      '?'.freeze => :question,
+      '-'.freeze => :dash
+    }
+    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
    SINGLE_STRING_LITERAL = /'[^\']*'/
    DOUBLE_STRING_LITERAL = /"[^\"]*"/
-    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
-    DOTDOT                = /\.\./
-    COMPARISON_OPERATOR   = /==|!=|<>|<=?|>=?|contains(?=\s)/
-    WHITESPACE_OR_NOTHING = /\s*/
+    NUMBER_LITERAL = /-?\d+(\.\d+)?/
+    DOTDOT = /\.\./
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/

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

    def tokenize
      @output = []

      until @ss.eos?
-        @ss.skip(WHITESPACE_OR_NOTHING)
-        break if @ss.eos?
-        tok      = if (t = @ss.scan(COMPARISON_OPERATOR))
-          [:comparison, t]
-        elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
-          [:string, t]
-        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL))
-          [:string, t]
-        elsif (t = @ss.scan(NUMBER_LITERAL))
-          [:number, t]
-        elsif (t = @ss.scan(IDENTIFIER))
-          [:id, t]
-        elsif (t = @ss.scan(DOTDOT))
-          [:dotdot, t]
+        @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])
+          c = @ss.getch
+          if s = SPECIALS[c]
            [s, c]
          else
            raise SyntaxError, "Unexpected character #{c}"
--- a/lib/liquid/locales/en.yml
+++ b/lib/liquid/locales/en.yml
@@ -14,7 +14,7 @@
      if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
      include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
      unknown_tag: "Unknown tag '%{tag}'"
-      invalid_delimiter: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
      unexpected_else: "%{block_name} tag does not expect 'else' tag"
      unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
@@ -22,8 +22,5 @@
      tag_never_closed: "'%{block_name}' tag was never closed"
      meta_syntax_error: "Liquid syntax error: #{e.message}"
      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
-      render: "Syntax error in tag 'render' - Template name must be a quoted string"
    argument:
      include: "Argument error in tag 'include' - Illegal template name"
-    disabled:
-      tag: "usage is not allowed in this context"
--- a/lib/liquid/parse_context.rb
+++ b/lib/liquid/parse_context.rb
@@ -1,17 +1,12 @@
-# frozen_string_literal: true
-
 module Liquid
  class ParseContext
-    attr_accessor :locale, :line_number, :trim_whitespace, :depth
+    attr_accessor :locale, :line_number, :trim_whitespace
    attr_reader :partial, :warnings, :error_mode

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

@@ -22,8 +17,8 @@ module Liquid
    def partial=(value)
      @partial = value
      @options = value ? partial_options : @template_options
-
      @error_mode = @options[:error_mode] || Template.error_mode
+      value
    end

    def partial_options
@@ -32,7 +27,7 @@ module Liquid
        if dont_pass == true
          { locale: locale }
        elsif dont_pass.is_a?(Array)
-          @template_options.reject { |k, _v| dont_pass.include?(k) }
+          @template_options.reject { |k, v| dont_pass.include?(k) }
        else
          @template_options
        end
--- a/lib/liquid/parse_tree_visitor.rb
+++ b/lib/liquid/parse_tree_visitor.rb
@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class ParseTreeVisitor
-    def self.for(node, callbacks = Hash.new(proc {}))
-      if defined?(node.class::ParseTreeVisitor)
-        node.class::ParseTreeVisitor
-      else
-        self
-      end.new(node, callbacks)
-    end
-
-    def initialize(node, callbacks)
-      @node      = node
-      @callbacks = callbacks
-    end
-
-    def add_callback_for(*classes, &block)
-      callback = block
-      callback = ->(node, _) { yield node } if block.arity.abs == 1
-      callback = ->(_, _) { yield } if block.arity.zero?
-      classes.each { |klass| @callbacks[klass] = callback }
-      self
-    end
-
-    def visit(context = nil)
-      children.map do |node|
-        item, new_context = @callbacks[node.class].call(node, context)
-        [
-          item,
-          ParseTreeVisitor.for(node, @callbacks).visit(new_context || context),
-        ]
-      end
-    end
-
-    protected
-
-    def children
-      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : []
-    end
-  end
-end
--- a/lib/liquid/parser.rb
+++ b/lib/liquid/parser.rb
@@ -1,11 +1,9 @@
-# frozen_string_literal: true
-
 module Liquid
  class Parser
    def initialize(input)
-      l       = Lexer.new(input)
+      l = Lexer.new(input)
      @tokens = l.tokenize
-      @p      = 0 # pointer to current location
+      @p = 0 # pointer to current location
    end

    def jump(point)
@@ -46,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
@@ -68,10 +63,10 @@ module Liquid
    end

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

      str << expression
--- a/lib/liquid/parser_switching.rb
+++ b/lib/liquid/parser_switching.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  module ParserSwitching
    def parse_with_selected_parser(markup)
@@ -8,10 +6,10 @@ module Liquid
      when :lax    then lax_parse(markup)
      when :warn
        begin
-          strict_parse_with_error_context(markup)
+          return strict_parse_with_error_context(markup)
        rescue SyntaxError => e
          parse_context.warnings << e
-          lax_parse(markup)
+          return lax_parse(markup)
        end
      end
    end
@@ -21,7 +19,7 @@ module Liquid
    def strict_parse_with_error_context(markup)
      strict_parse(markup)
    rescue SyntaxError => e
-      e.line_number    = line_number
+      e.line_number = line_number
      e.markup_context = markup_context(markup)
      raise e
    end
--- a/lib/liquid/partial_cache.rb
+++ b/lib/liquid/partial_cache.rb
@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class PartialCache
-    def self.load(template_name, context:, parse_context:)
-      cached_partials = (context.registers[:cached_partials] ||= {})
-      cached = cached_partials[template_name]
-      return cached if cached
-
-      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
-      source      = file_system.read_template_file(template_name)
-
-      parse_context.partial = true
-
-      template_factory = (context.registers[:template_factory] ||= Liquid::TemplateFactory.new)
-      template = template_factory.for(template_name)
-
-      partial = template.parse(source, parse_context)
-      cached_partials[template_name] = partial
-    ensure
-      parse_context.partial = false
-    end
-  end
-end
--- a/lib/liquid/profiler.rb
+++ b/lib/liquid/profiler.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'liquid/profiler/hooks'

 module Liquid
@@ -46,7 +44,7 @@ module Liquid
    include Enumerable

    class Timing
-      attr_reader :code, :partial, :line_number, :children, :total_time, :self_time
+      attr_reader :code, :partial, :line_number, :children

      def initialize(node, partial)
        @code        = node.respond_to?(:raw) ? node.raw : node
@@ -64,18 +62,7 @@ module Liquid
      end

      def finish
-        @end_time   = Time.now
-        @total_time = @end_time - @start_time
-
-        if @children.empty?
-          @self_time = @total_time
-        else
-          total_children_time = 0
-          @children.each do |child|
-            total_children_time += child.total_time
-          end
-          @self_time = @total_time - total_children_time
-        end
+        @end_time = Time.now
      end

      def render_time
@@ -109,14 +96,14 @@ module Liquid
      Thread.current[:liquid_profiler]
    end

-    def initialize(partial_name = "<root>")
-      @partial_stack = [partial_name]
+    def initialize
+      @partial_stack = ["<root>"]

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

      @render_start_at = Time.now
-      @render_end_at   = @render_start_at
+      @render_end_at = @render_start_at
    end

    def start
--- a/lib/liquid/profiler/hooks.rb
+++ b/lib/liquid/profiler/hooks.rb
@@ -1,21 +1,23 @@
-# frozen_string_literal: true
-
 module Liquid
-  module BlockBodyProfilingHook
-    def render_node(context, output, node)
+  class BlockBody
+    def render_node_with_profiling(node, context)
      Profiler.profile_node_render(node) do
-        super
+        render_node_without_profiling(node, context)
      end
    end
-  end
-  BlockBody.prepend(BlockBodyProfilingHook)

-  module IncludeProfilingHook
-    def render_to_output_buffer(context, output)
+    alias_method :render_node_without_profiling, :render_node
+    alias_method :render_node, :render_node_with_profiling
+  end
+
+  class Include < Tag
+    def render_with_profiling(context)
      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        super
+        render_without_profiling(context)
      end
    end
+
+    alias_method :render_without_profiling, :render
+    alias_method :render, :render_with_profiling
  end
-  Include.prepend(IncludeProfilingHook)
 end
--- a/lib/liquid/range_lookup.rb
+++ b/lib/liquid/range_lookup.rb
@@ -1,10 +1,8 @@
-# frozen_string_literal: true
-
 module Liquid
  class RangeLookup
    def self.parse(start_markup, end_markup)
      start_obj = Expression.parse(start_markup)
-      end_obj   = Expression.parse(end_markup)
+      end_obj = Expression.parse(end_markup)
      if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
        new(start_obj, end_obj)
      else
@@ -14,12 +12,12 @@ module Liquid

    def initialize(start_obj, end_obj)
      @start_obj = start_obj
-      @end_obj   = end_obj
+      @end_obj = end_obj
    end

    def evaluate(context)
      start_int = to_integer(context.evaluate(@start_obj))
-      end_int   = to_integer(context.evaluate(@end_obj))
+      end_int = to_integer(context.evaluate(@end_obj))
      start_int..end_int
    end

--- a/lib/liquid/register.rb
+++ b/lib/liquid/register.rb
@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Register
-  end
-end
--- a/lib/liquid/resource_limits.rb
+++ b/lib/liquid/resource_limits.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class ResourceLimits
    attr_accessor :render_length, :render_score, :assign_score,
@@ -7,8 +5,8 @@ module Liquid

    def initialize(limits)
      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit  = limits[:render_score_limit]
-      @assign_score_limit  = limits[:assign_score_limit]
+      @render_score_limit = limits[:render_score_limit]
+      @assign_score_limit = limits[:assign_score_limit]
      reset
    end

--- a/lib/liquid/standardfilters.rb
+++ b/lib/liquid/standardfilters.rb
@@ -1,24 +1,16 @@
-# frozen_string_literal: true
-
 require 'cgi'
 require 'bigdecimal'

 module Liquid
  module StandardFilters
    HTML_ESCAPE = {
-      '&' => '&amp;',
-      '>' => '&gt;',
-      '<' => '&lt;',
-      '"' => '&quot;',
-      "'" => '&#39;',
-    }.freeze
+      '&'.freeze => '&amp;'.freeze,
+      '>'.freeze => '&gt;'.freeze,
+      '<'.freeze => '&lt;'.freeze,
+      '"'.freeze => '&quot;'.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)
@@ -41,7 +33,7 @@ module Liquid
    end

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

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

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

    def url_decode(input)
-      return if input.nil?
-
-      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)
@@ -74,28 +61,23 @@ module Liquid
    end

    # Truncate a string down to x characters
-    def truncate(input, length = 50, truncate_string = "...")
+    def truncate(input, length = 50, truncate_string = "...".freeze)
      return if input.nil?
      input_str = input.to_s
-      length    = Utils.to_integer(length)
-
+      length = Utils.to_integer(length)
      truncate_string_str = truncate_string.to_s
-
      l = length - truncate_string_str.length
      l = 0 if l < 0
-
-      input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
+      input_str.length > length ? input_str[0...l] + truncate_string_str : input_str
    end

-    def truncatewords(input, words = 15, truncate_string = "...")
+    def truncatewords(input, words = 15, truncate_string = "...".freeze)
      return if input.nil?
      wordlist = input.to_s.split
-      words    = Utils.to_integer(words)
-
+      words = Utils.to_integer(words)
      l = words - 1
      l = 0 if l < 0
-
-      wordlist.length > l ? wordlist[0..l].join(" ").concat(truncate_string.to_s) : input
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string.to_s : input
    end

    # Split input string into an array of substrings separated by given pattern.
@@ -120,38 +102,37 @@ module Liquid
    end

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

    # Remove all newlines from the string
    def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, '')
+      input.to_s.gsub(/\r?\n/, ''.freeze)
    end

    # Join elements of the array with certain character between them
-    def join(input, glue = ' ')
-      InputIterator.new(input, context).join(glue)
+    def join(input, glue = ' '.freeze)
+      InputIterator.new(input).join(glue)
    end

    # Sort elements of the array
    # provide optional property with which to sort an array of hashes or drops
    def sort(input, property = nil)
-      ary = InputIterator.new(input, context)
-
-      return [] if ary.empty?
-
+      ary = InputIterator.new(input)
      if property.nil?
+        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 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)
+          a = a[property]
+          b = b[property]
+          if a && b
+            a <=> b
+          else
+            a ? -1 : 1
+          end
        end
      end
    end
@@ -159,121 +140,83 @@ module Liquid
    # Sort elements of an array ignoring case if strings
    # provide optional property with which to sort an array of hashes or drops
    def sort_natural(input, property = nil)
-      ary = InputIterator.new(input, context)
-
-      return [] if ary.empty?
+      ary = InputIterator.new(input)

      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, context)
-
-      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

    # Remove duplicate elements from an array
    # provide optional property with which to determine uniqueness
    def uniq(input, property = nil)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)

      if property.nil?
        ary.uniq
      elsif ary.empty? # The next two cases assume a non-empty array.
        []
      elsif ary.first.respond_to?(:[])
-        begin
-          ary.uniq { |a| a[property] }
-        rescue TypeError
-          raise_property_error(property)
-        end
+        ary.uniq{ |a| a[property] }
      end
    end

    # Reverse the elements of an array
    def reverse(input)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)
      ary.reverse
    end

    # map/collect on a given property
    def map(input, property)
-      InputIterator.new(input, context).map do |e|
+      InputIterator.new(input).map do |e|
        e = e.call if e.is_a?(Proc)

-        if property == "to_liquid"
+        if property == "to_liquid".freeze
          e
        elsif e.respond_to?(:[])
          r = e[property]
          r.is_a?(Proc) ? r.call : r
        end
      end
-    rescue TypeError
-      raise_property_error(property)
    end

    # Remove nils within an array
    # provide optional property with which to check for nil
    def compact(input, property = nil)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)

      if property.nil?
        ary.compact
      elsif ary.empty? # The next two cases assume a non-empty array.
        []
      elsif ary.first.respond_to?(:[])
-        begin
-          ary.reject { |a| a[property].nil? }
-        rescue TypeError
-          raise_property_error(property)
-        end
+        ary.reject{ |a| a[property].nil? }
      end
    end

    # Replace occurrences of a string with another
-    def replace(input, string, replacement = '')
+    def replace(input, string, replacement = ''.freeze)
      input.to_s.gsub(string.to_s, replacement.to_s)
    end

    # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = '')
+    def replace_first(input, string, replacement = ''.freeze)
      input.to_s.sub(string.to_s, replacement.to_s)
    end

    # remove a substring
    def remove(input, string)
-      input.to_s.gsub(string.to_s, '')
+      input.to_s.gsub(string.to_s, ''.freeze)
    end

    # remove the first occurrences of a substring
    def remove_first(input, string)
-      input.to_s.sub(string.to_s, '')
+      input.to_s.sub(string.to_s, ''.freeze)
    end

    # add one string to another
@@ -283,9 +226,9 @@ module Liquid

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

    # prepend a string to another
@@ -295,7 +238,7 @@ module Liquid

    # Add <br /> tags in front of all newlines in input string
    def newline_to_br(input)
-      input.to_s.gsub(/\n/, "<br />\n")
+      input.to_s.gsub(/\n/, "<br />\n".freeze)
    end

    # Reformat a date using Ruby's core Time#strftime( string ) -> string
@@ -332,7 +275,7 @@ module Liquid
    def date(input, format)
      return input if format.to_s.empty?

-      return input unless (date = Utils.to_date(input))
+      return input unless date = Utils.to_date(input)

      date.strftime(format.to_s)
    end
@@ -410,73 +353,26 @@ 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
-
-    # Set a default value when the input is nil, false or empty
-    #
-    # Example:
-    #    {{ product.title | default: "No Title" }}
-    #
-    # Use `allow_false` when an input should only be tested against nil or empty and not false.
-    #
-    # Example:
-    #    {{ product.title | default: "No Title", allow_false: true }}
-    #
-    def default(input, default_value = '', options = {})
-      options = {} unless options.is_a?(Hash)
-      false_check = options['allow_false'] ? input.nil? : !input
-      false_check || (input.respond_to?(:empty?) && input.empty?) ? default_value : input
+    def default(input, default_value = ''.freeze)
+      if !input || input.respond_to?(:empty?) && input.empty?
+        default_value
+      else
+        input
+      end
    end

    private

-    attr_reader :context
-
-    def raise_property_error(property)
-      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
-    end
-
    def apply_operation(input, operand, operation)
      result = Utils.to_number(input).send(operation, Utils.to_number(operand))
      result.is_a?(BigDecimal) ? result.to_f : result
    end

-    def nil_safe_compare(a, b)
-      if !a.nil? && !b.nil?
-        a <=> b
-      else
-        a.nil? ? 1 : -1
-      end
-    end
-
-    def nil_safe_casecmp(a, b)
-      if !a.nil? && !b.nil?
-        a.to_s.casecmp(b.to_s)
-      else
-        a.nil? ? 1 : -1
-      end
-    end
-
    class InputIterator
      include Enumerable

-      def initialize(input, context)
-        @context = context
-        @input   = if input.is_a?(Array)
+      def initialize(input)
+        @input = if input.is_a?(Array)
          input.flatten
        elsif input.is_a?(Hash)
          [input]
@@ -488,7 +384,7 @@ module Liquid
      end

      def join(glue)
-        to_a.join(glue.to_s)
+        to_a.join(glue)
      end

      def concat(args)
@@ -514,7 +410,6 @@ module Liquid

      def each
        @input.each do |e|
-          e.context = @context if e.respond_to?(:context=)
          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
        end
      end
--- a/lib/liquid/static_registers.rb
+++ b/lib/liquid/static_registers.rb
@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class StaticRegisters
-    attr_reader :static
-
-    def initialize(registers = {})
-      @static    = registers.is_a?(StaticRegisters) ? registers.static : registers
-      @registers = {}
-    end
-
-    def []=(key, value)
-      @registers[key] = value
-    end
-
-    def [](key)
-      if @registers.key?(key)
-        @registers[key]
-      else
-        @static[key]
-      end
-    end
-
-    def delete(key)
-      @registers.delete(key)
-    end
-
-    UNDEFINED = Object.new
-
-    def fetch(key, default = UNDEFINED, &block)
-      if @registers.key?(key)
-        @registers.fetch(key)
-      elsif default != UNDEFINED
-        @static.fetch(key, default, &block)
-      else
-        @static.fetch(key, &block)
-      end
-    end
-
-    def key?(key)
-      @registers.key?(key) || @static.key?(key)
-    end
-  end
-end
--- a/lib/liquid/strainer.rb
+++ b/lib/liquid/strainer.rb
@@ -0,0 +1,66 @@
+require 'set'
+
+module Liquid
+  # Strainer is the parent class for the filters system.
+  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
+  #
+  # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
+  # Context#add_filters or Template.register_filter
+  class Strainer #:nodoc:
+    @@global_strainer = Class.new(Strainer) do
+      @filter_methods = Set.new
+    end
+    @@strainer_class_cache = Hash.new do |hash, filters|
+      hash[filters] = Class.new(@@global_strainer) do
+        @filter_methods = @@global_strainer.filter_methods.dup
+        filters.each { |f| add_filter(f) }
+      end
+    end
+
+    def initialize(context)
+      @context = context
+    end
+
+    class << self
+      attr_reader :filter_methods
+    end
+
+    def self.add_filter(filter)
+      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
+      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(', ')}"
+        else
+          send(:include, filter)
+          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+        end
+      end
+    end
+
+    def self.global_filter(filter)
+      @@strainer_class_cache.clear
+      @@global_strainer.add_filter(filter)
+    end
+
+    def self.invokable?(method)
+      @filter_methods.include?(method.to_s)
+    end
+
+    def self.create(context, filters = [])
+      @@strainer_class_cache[filters].new(context)
+    end
+
+    def invoke(method, *args)
+      if self.class.invokable?(method)
+        send(method, *args)
+      elsif @context && @context.strict_filters
+        raise Liquid::UndefinedFilter, "undefined filter #{method}"
+      else
+        args.first
+      end
+    rescue ::ArgumentError => e
+      raise Liquid::ArgumentError, e.message, e.backtrace
+    end
+  end
+end
--- a/lib/liquid/strainer_factory.rb
+++ b/lib/liquid/strainer_factory.rb
@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # StrainerFactory is the factory for the filters system.
-  module StrainerFactory
-    extend self
-
-    def add_global_filter(filter)
-      strainer_class_cache.clear
-      global_filters << filter
-    end
-
-    def create(context, filters = [])
-      strainer_from_cache(filters).new(context)
-    end
-
-    private
-
-    def global_filters
-      @global_filters ||= []
-    end
-
-    def strainer_from_cache(filters)
-      strainer_class_cache[filters] ||= begin
-        klass = Class.new(StrainerTemplate)
-        global_filters.each { |f| klass.add_filter(f) }
-        filters.each { |f| klass.add_filter(f) }
-        klass
-      end
-    end
-
-    def strainer_class_cache
-      @strainer_class_cache ||= {}
-    end
-  end
-end
--- a/lib/liquid/strainer_template.rb
+++ b/lib/liquid/strainer_template.rb
@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-
-module Liquid
-  # StrainerTemplate is the computed class for the filters system.
-  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
-  #
-  # The Strainer only allows method calls defined in filters given to it via StrainerFactory.add_global_filter,
-  # Context#add_filters or Template.register_filter
-  class StrainerTemplate
-    def initialize(context)
-      @context = context
-    end
-
-    class << self
-      def add_filter(filter)
-        return if include?(filter)
-
-        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
-        if invokable_non_public_methods.any?
-          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
-        end
-
-        include(filter)
-
-        filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-      end
-
-      def invokable?(method)
-        filter_methods.include?(method.to_s)
-      end
-
-      private
-
-      def filter_methods
-        @filter_methods ||= Set.new
-      end
-    end
-
-    def invoke(method, *args)
-      if self.class.invokable?(method)
-        send(method, *args)
-      elsif @context.strict_filters
-        raise Liquid::UndefinedFilter, "undefined filter #{method}"
-      else
-        args.first
-      end
-    rescue ::ArgumentError => e
-      raise Liquid::ArgumentError, e.message, e.backtrace
-    end
-  end
-end
--- a/lib/liquid/tablerowloop_drop.rb
+++ b/lib/liquid/tablerowloop_drop.rb
@@ -1,13 +1,11 @@
-# frozen_string_literal: true
-
 module Liquid
  class TablerowloopDrop < Drop
    def initialize(length, cols)
      @length = length
-      @row    = 1
-      @col    = 1
-      @cols   = cols
-      @index  = 0
+      @row = 1
+      @col = 1
+      @cols = cols
+      @index = 0
    end

    attr_reader :length, :col, :row
--- a/lib/liquid/tag.rb
+++ b/lib/liquid/tag.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Tag
    attr_reader :nodelist, :tag_name, :line_number, :parse_context
@@ -7,26 +5,20 @@ 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

-      def disable_tags(*tag_names)
-        @disabled_tags ||= []
-        @disabled_tags.concat(tag_names)
-        prepend(Disabler)
-      end
-
      private :new
    end

    def initialize(tag_name, markup, parse_context)
-      @tag_name      = tag_name
-      @markup        = markup
+      @tag_name   = tag_name
+      @markup     = markup
      @parse_context = parse_context
-      @line_number   = parse_context.line_number
+      @line_number = parse_context.line_number
    end

    def parse(_tokens)
@@ -41,15 +33,7 @@ module Liquid
    end

    def render(_context)
-      ''
-    end
-
-    # For backwards compatibility with custom tags. In a future release, the semantics
-    # of the `render_to_output_buffer` method will become the default and the `render`
-    # method will be removed.
-    def render_to_output_buffer(context, output)
-      output << render(context)
-      output
+      ''.freeze
    end

    def blank?
--- a/lib/liquid/tag/disableable.rb
+++ b/lib/liquid/tag/disableable.rb
@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Tag
-    module Disableable
-      def render_to_output_buffer(context, output)
-        if context.tag_disabled?(tag_name)
-          output << disabled_error(context)
-          return
-        end
-        super
-      end
-
-      def disabled_error(context)
-        # raise then rescue the exception so that the Context#exception_renderer can re-raise it
-        raise DisabledError, "#{tag_name} #{parse_context[:locale].t('errors.disabled.tag')}"
-      rescue DisabledError => exc
-        context.handle_error(exc, line_number)
-      end
-    end
-  end
-end
--- a/lib/liquid/tag/disabler.rb
+++ b/lib/liquid/tag/disabler.rb
@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Tag
-    module Disabler
-      module ClassMethods
-        attr_reader :disabled_tags
-      end
-
-      def self.prepended(base)
-        base.extend(ClassMethods)
-      end
-
-      def render_to_output_buffer(context, output)
-        context.with_disabled_tags(self.class.disabled_tags) do
-          super
-        end
-      end
-    end
-  end
-end
--- a/lib/liquid/tags/assign.rb
+++ b/lib/liquid/tags/assign.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Assign sets a variable in your template.
  #
@@ -12,23 +10,21 @@ module Liquid
  class Assign < Tag
    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om

-    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('errors.syntax.assign')
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
      end
    end

-    def render_to_output_buffer(context, output)
+    def render(context)
      val = @from.render(context)
      context.scopes.last[@to] = val
      context.resource_limits.assign_score += assign_score_of(val)
-      output
+      ''.freeze
    end

    def blank?
@@ -39,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.
@@ -49,13 +45,7 @@ module Liquid
        1
      end
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.from]
-      end
-    end
  end

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

-  Template.register_tag('break', Break)
+  Template.register_tag('break'.freeze, Break)
 end
--- a/lib/liquid/tags/capture.rb
+++ b/lib/liquid/tags/capture.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Capture stores the result of a block into a variable without rendering it inplace.
  #
@@ -18,17 +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)
-      capture_output = render(context)
-      context.scopes.last[@to] = capture_output
-      context.resource_limits.assign_score += capture_output.bytesize
-      output
+    def render(context)
+      output = super
+      context.scopes.last[@to] = output
+      context.resource_limits.assign_score += output.length
+      ''.freeze
    end

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

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

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

      if markup =~ Syntax
-        @left = Expression.parse(Regexp.last_match(1))
+        @left = Expression.parse($1)
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.case")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
      end
    end

    def parse(tokens)
      body = BlockBody.new
-      body = @blocks.last.attachment while parse_body(body, tokens)
-      @blank = @blocks.all? { |condition| condition.attachment.blank? }
-      if @blank
-        @blocks.each { |condition| condition.attachment.remove_blank_strings }
+      while parse_body(body, tokens)
+        body = @blocks.last.attachment
      end
    end

-    def blank?
-      @blank
-    end
-
    def nodelist
      @blocks.map(&:attachment)
    end

    def unknown_tag(tag, markup, tokens)
      case tag
-      when 'when'
+      when 'when'.freeze
        record_when_condition(markup)
-      when 'else'
+      when 'else'.freeze
        record_else_condition(markup)
      else
        super
      end
    end

-    def render_to_output_buffer(context, output)
-      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
@@ -68,12 +60,12 @@ module Liquid

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

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

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

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

      block = ElseCondition.new
      block.attach(BlockBody.new)
      @blocks << block
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.left] + @node.blocks
-      end
-    end
  end

-  Template.register_tag('case', Case)
+  Template.register_tag('case'.freeze, Case)
 end
--- a/lib/liquid/tags/comment.rb
+++ b/lib/liquid/tags/comment.rb
@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
  class Comment < Block
-    def render_to_output_buffer(_context, output)
-      output
+    def render(_context)
+      ''.freeze
    end

    def unknown_tag(_tag, _markup, _tokens)
@@ -14,5 +12,5 @@ module Liquid
    end
  end

-  Template.register_tag('comment', Comment)
+  Template.register_tag('comment'.freeze, Comment)
 end
--- a/lib/liquid/tags/continue.rb
+++ b/lib/liquid/tags/continue.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Continue tag to be used to break out of a for loop.
  #
@@ -11,13 +9,10 @@ module Liquid
  #    {% endfor %}
  #
  class Continue < Tag
-    INTERRUPT = ContinueInterrupt.new.freeze
-
-    def render_to_output_buffer(context, output)
-      context.push_interrupt(INTERRUPT)
-      output
+    def interrupt
+      ContinueInterrupt.new
    end
  end

-  Template.register_tag('continue', Continue)
+  Template.register_tag('continue'.freeze, Continue)
 end
--- a/lib/liquid/tags/cycle.rb
+++ b/lib/liquid/tags/cycle.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
  #
@@ -17,43 +15,32 @@ module Liquid
    SimpleSyntax = /\A#{QuotedFragment}+/o
    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om

-    attr_reader :variables
-
    def initialize(tag_name, markup, options)
      super
      case markup
      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
-        @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
+        @name = @variables.to_s
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
      end
    end

-    def render_to_output_buffer(context, output)
-      context.registers[:cycle] ||= {}
+    def render(context)
+      context.registers[:cycle] ||= Hash.new(0)

-      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
@@ -61,15 +48,9 @@ module Liquid
    def variables_from_string(markup)
      markup.split(',').collect do |var|
        var =~ /\s*(#{QuotedFragment})\s*/o
-        Regexp.last_match(1) ? 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
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # decrement is used in a place where one needs to insert a counter
  #     into a template, and needs the counter to survive across
@@ -25,14 +23,13 @@ module Liquid
      @variable = markup.strip
    end

-    def render_to_output_buffer(context, output)
+    def render(context)
      value = context.environments.first[@variable] ||= 0
      value -= 1
      context.environments.first[@variable] = value
-      output << value.to_s
-      output
+      value.to_s
    end
  end

-  Template.register_tag('decrement', Decrement)
+  Template.register_tag('decrement'.freeze, Decrement)
 end
--- a/lib/liquid/tags/echo.rb
+++ b/lib/liquid/tags/echo.rb
@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  # Echo outputs an expression
-  #
-  #   {% echo monkey %}
-  #   {% echo user.name %}
-  #
-  # This is identical to variable output syntax, like {{ foo }}, but works
-  # inside {% liquid %} tags. The full syntax is supported, including filters:
-  #
-  #   {% echo user | link %}
-  #
-  class Echo < Tag
-    def initialize(tag_name, markup, parse_context)
-      super
-      @variable = Variable.new(markup, parse_context)
-    end
-
-    def render(context)
-      @variable.render_to_output_buffer(context, +'')
-    end
-  end
-
-  Template.register_tag('echo', Echo)
-end
--- a/lib/liquid/tags/for.rb
+++ b/lib/liquid/tags/for.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # "For" iterates over an array or collection.
  # Several useful variables are available to you within the loop.
@@ -25,7 +23,7 @@ module Liquid
  #      {{ item.name }}
  #    {% end %}
  #
-  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
+  #  To reverse the for loop simply use {% for item in collection reversed %}
  #
  # == Available variables:
  #
@@ -48,8 +46,6 @@ 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
@@ -59,18 +55,8 @@ module Liquid
    end

    def parse(tokens)
-      if parse_body(@for_block, tokens)
-        parse_body(@else_block, tokens)
-      end
-      @blank = @for_block.blank? && (@else_block.nil? || @else_block.blank?)
-      if @blank
-        @for_block.remove_blank_strings
-        @else_block&.remove_blank_strings
-      end
-    end
-
-    def blank?
-      @blank
+      return unless parse_body(@for_block, tokens)
+      parse_body(@else_block, tokens)
    end

    def nodelist
@@ -78,53 +64,49 @@ module Liquid
    end

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

-    def render_to_output_buffer(context, output)
+    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)
-        @name            = "#{@variable_name}-#{collection_name}"
+        @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")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
      end
    end

    def strict_parse(markup)
      p = Parser.new(markup)
      @variable_name = p.consume(:id)
-      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
-
-      collection_name  = p.expression
+      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)
-
-      @name     = "#{@variable_name}-#{collection_name}"
-      @reversed = p.id?('reversed')
+      @reversed = p.id?('reversed'.freeze)

      while p.look(:id) && p.look(:colon, 1)
-        unless (attribute = p.id?('limit') || p.id?('offset'))
-          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
        end
        p.consume
        set_attribute(attribute, p.expression)
@@ -135,28 +117,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
@@ -166,9 +139,11 @@ module Liquid
      segment
    end

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

      context.stack do
        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
@@ -176,54 +151,45 @@ module Liquid
        for_stack.push(loop_vars)

        begin
-          context['forloop'] = loop_vars
+          context['forloop'.freeze] = loop_vars

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

            # Handle any interrupts if they exist.
-            next unless context.interrupt?
-            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)
      case key
-      when 'offset'
-        @from = if expr == 'continue'
+      when 'offset'.freeze
+        @from = if expr == 'continue'.freeze
          :continue
        else
          Expression.parse(expr)
        end
-      when 'limit'
+      when 'limit'.freeze
        @limit = Expression.parse(expr)
      end
    end

-    def render_else(context, output)
-      if @else_block
-        @else_block.render_to_output_buffer(context, output)
-      else
-        output
-      end
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        (super + [@node.limit, @node.from, @node.collection_name]).compact
-      end
+    def render_else(context)
+      @else_block ? @else_block.render(context) : ''.freeze
    end
  end

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

    def initialize(tag_name, markup, options)
      super
      @blocks = []
-      push_block('if', markup)
+      push_block('if'.freeze, markup)
+    end
+
+    def parse(tokens)
+      while parse_body(@blocks.last.attachment, tokens)
+      end
    end

    def nodelist
      @blocks.map(&:attachment)
    end

-    def parse(tokens)
-      while parse_body(@blocks.last.attachment, tokens)
-      end
-      @blank = @blocks.all? { |condition| condition.attachment.blank? }
-      if @blank
-        @blocks.each { |condition| condition.attachment.remove_blank_strings }
-      end
-    end
-
-    def blank?
-      @blank
-    end
-
    def unknown_tag(tag, markup, tokens)
-      if ['elsif', 'else'].include?(tag)
+      if ['elsif'.freeze, 'else'.freeze].include?(tag)
        push_block(tag, markup)
      else
        super
      end
    end

-    def render_to_output_buffer(context, output)
-      @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

    def push_block(tag, markup)
-      block = if tag == 'else'
+      block = if tag == 'else'.freeze
        ElseCondition.new
      else
        parse_with_selected_parser(markup)
@@ -74,17 +63,17 @@ module Liquid

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

-      condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+      condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))

      until expressions.empty?
        operator = expressions.pop.to_s.strip

-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+        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") 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
@@ -94,38 +83,29 @@ module Liquid

    def strict_parse(markup)
      p = Parser.new(markup)
-      condition = parse_binary_comparisons(p)
+      condition = parse_binary_comparison(p)
      p.consume(:end_of_string)
      condition
    end

-    def parse_binary_comparisons(p)
+    def parse_binary_comparison(p)
      condition = parse_comparison(p)
-      first_condition = condition
-      while (op = (p.id?('and') || p.id?('or')))
-        child_condition = parse_comparison(p)
-        condition.send(op, child_condition)
-        condition = child_condition
+      if op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+        condition.send(op, parse_binary_comparison(p))
      end
-      first_condition
+      condition
    end

    def parse_comparison(p)
      a = Expression.parse(p.expression)
-      if (op = p.consume?(:comparison))
+      if op = p.consume?(:comparison)
        b = Expression.parse(p.expression)
        Condition.new(a, op, b)
      else
        Condition.new(a)
      end
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        @node.blocks
-      end
-    end
  end

-  Template.register_tag('if', If)
+  Template.register_tag('if'.freeze, If)
 end
--- a/lib/liquid/tags/ifchanged.rb
+++ b/lib/liquid/tags/ifchanged.rb
@@ -1,19 +1,18 @@
-# frozen_string_literal: true
-
 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

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

    def initialize(tag_name, markup, options)
      super

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

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

-        @alias_name         = Regexp.last_match(5)
        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
        @template_name_expr = Expression.parse(template_name)
-        @attributes         = {}
+        @attributes = {}

        markup.scan(TagAttributes) do |key, value|
          @attributes[key] = Expression.parse(value)
        end

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

    def parse(_tokens)
    end

-    def 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
+      raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name

-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context
-      )
-
-      context_variable_name = @alias_name || template_name.split('/').last
+      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
-      old_partial       = context.partial
+      old_partial = context.partial
      begin
        context.template_name = template_name
-        context.partial       = true
+        context.partial = true
        context.stack do
          @attributes.each do |key, value|
            context[key] = context.evaluate(value)
          end

          if variable.is_a?(Array)
-            variable.each do |var|
+            variable.collect do |var|
              context[context_variable_name] = var
-              partial.render_to_output_buffer(context, output)
+              partial.render(context)
            end
          else
            context[context_variable_name] = variable
-            partial.render_to_output_buffer(context, output)
+            partial.render(context)
          end
        end
      ensure
        context.template_name = old_template_name
-        context.partial       = old_partial
+        context.partial = old_partial
      end
-
-      output
    end

+    private
+
    alias_method :parse_context, :options
    private :parse_context

-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def 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

-  Template.register_tag('include', Include)
+  Template.register_tag('include'.freeze, Include)
 end
--- a/lib/liquid/tags/increment.rb
+++ b/lib/liquid/tags/increment.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # increment is used in a place where one needs to insert a counter
  #     into a template, and needs the counter to survive across
@@ -22,14 +20,12 @@ module Liquid
      @variable = markup.strip
    end

-    def render_to_output_buffer(context, output)
+    def render(context)
      value = context.environments.first[@variable] ||= 0
      context.environments.first[@variable] = value + 1
-
-      output << value.to_s
-      output
+      value.to_s
    end
  end

-  Template.register_tag('increment', Increment)
+  Template.register_tag('increment'.freeze, Increment)
 end
--- a/lib/liquid/tags/raw.rb
+++ b/lib/liquid/tags/raw.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  class Raw < Block
    Syntax = /\A\s*\z/
@@ -12,21 +10,20 @@ module Liquid
    end

    def parse(tokens)
-      @body = +''
-      while (token = tokens.shift)
+      @body = ''
+      while token = tokens.shift
        if token =~ FullTokenPossiblyInvalid
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
-          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", 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
@@ -40,11 +37,11 @@ module Liquid
    protected

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

-  Template.register_tag('raw', Raw)
+  Template.register_tag('raw'.freeze, Raw)
 end
--- a/lib/liquid/tags/render.rb
+++ b/lib/liquid/tags/render.rb
@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class Render < Tag
-    FOR = 'for'
-    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
-
-    disable_tags "include"
-
-    attr_reader :template_name_expr, :attributes
-
-    def initialize(tag_name, markup, options)
-      super
-
-      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
-
-      template_name = Regexp.last_match(1)
-      with_or_for = Regexp.last_match(3)
-      variable_name = Regexp.last_match(4)
-
-      @alias_name = Regexp.last_match(6)
-      @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
-      @template_name_expr = Expression.parse(template_name)
-      @for = (with_or_for == FOR)
-
-      @attributes = {}
-      markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = Expression.parse(value)
-      end
-    end
-
-    def render_to_output_buffer(context, output)
-      render_tag(context, output)
-    end
-
-    def render_tag(context, output)
-      # Though we evaluate this here we will only ever parse it as a string literal.
-      template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
-
-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context
-      )
-
-      context_variable_name = @alias_name || template_name.split('/').last
-
-      render_partial_func = ->(var, forloop) {
-        inner_context               = context.new_isolated_subcontext
-        inner_context.template_name = template_name
-        inner_context.partial       = true
-        inner_context['forloop']    = forloop if forloop
-
-        @attributes.each do |key, value|
-          inner_context[key] = context.evaluate(value)
-        end
-        inner_context[context_variable_name] = var unless var.nil?
-        partial.render_to_output_buffer(inner_context, output)
-        forloop&.send(:increment!)
-      }
-
-      variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
-      if @for && variable.respond_to?(:each) && variable.respond_to?(:count)
-        forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
-        variable.each { |var| render_partial_func.call(var, forloop) }
-      else
-        render_partial_func.call(variable, nil)
-      end
-
-      output
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.template_name_expr,
-        ] + @node.attributes.values
-      end
-    end
-  end
-
-  Template.register_tag('render', Render)
-end
--- a/lib/liquid/tags/table_row.rb
+++ b/lib/liquid/tags/table_row.rb
@@ -1,66 +1,54 @@
-# frozen_string_literal: true
-
 module Liquid
  class TableRow < Block
    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o

-    attr_reader :variable_name, :collection_name, :attributes
-
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
-        @collection_name = Expression.parse(Regexp.last_match(2))
-        @attributes      = {}
+        @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")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
      end
    end

-    def render_to_output_buffer(context, output)
-      (collection = context.evaluate(@collection_name)) || (return '')
+    def render(context)
+      collection = context.evaluate(@collection_name) or return ''.freeze

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

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

-      cols = context.evaluate(@attributes['cols']).to_i
+      length = collection.length

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

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

-          output << "<td class=\"col#{tablerowloop.col}\">"
-          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

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

 module Liquid
@@ -8,23 +6,25 @@ 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

-  Template.register_tag('unless', Unless)
+  Template.register_tag('unless'.freeze, Unless)
 end
--- a/lib/liquid/template.rb
+++ b/lib/liquid/template.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Templates are central to liquid.
  # Interpretating templates is a two step process. First you compile the
@@ -18,11 +16,13 @@ module Liquid
    attr_accessor :root
    attr_reader :resource_limits, :warnings

+    @@file_system = BlankFileSystem.new
+
    class TagRegistry
      include Enumerable

      def initialize
-        @tags  = {}
+        @tags = {}
        @cache = {}
      end

@@ -50,7 +50,7 @@ module Liquid
      private

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

@@ -61,57 +61,76 @@ module Liquid
      # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
      # :warn is the default and will give deprecation warnings when invalid syntax is used.
      # :strict will enforce correct syntax.
-      attr_accessor :error_mode
-      Template.error_mode = :lax
+      attr_writer :error_mode
+
+      # Sets how strict the taint checker should be.
+      # :lax is the default, and ignores the taint flag completely
+      # :warn adds a warning, but does not interrupt the rendering
+      # :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

-      attr_accessor :file_system
-      Template.file_system = BlankFileSystem.new
+      def file_system
+        @@file_system
+      end

-      attr_accessor :tags
-      Template.tags = TagRegistry.new
-      private :tags=
+      def file_system=(obj)
+        @@file_system = obj
+      end

      def register_tag(name, klass)
        tags[name.to_s] = klass
      end

+      def tags
+        @tags ||= TagRegistry.new
+      end
+
+      def error_mode
+        @error_mode ||= :lax
+      end
+
+      def taint_mode
+        @taint_mode ||= :lax
+      end
+
      # Pass a module with filter methods which should be available
      # to all liquid views. Good for registering the standard library
      def register_filter(mod)
-        StrainerFactory.add_global_filter(mod)
+        Strainer.global_filter(mod)
      end

-      attr_accessor :default_resource_limits
-      Template.default_resource_limits = {}
-      private :default_resource_limits=
+      def default_resource_limits
+        @default_resource_limits ||= {}
+      end

      # creates a new <tt>Template</tt> object from liquid source code
      # To enable profiling, pass in <tt>profile: true</tt> as an option.
      # See Liquid::Profiler for more information
      def parse(source, options = {})
-        new.parse(source, options)
+        template = Template.new
+        template.parse(source, options)
      end
    end

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

    # Parse source code.
    # Returns self for easy chaining
    def parse(source, options = {})
-      @options      = options
-      @profiling    = options[:profile]
+      @options = options
+      @profiling = options[:profile]
      @line_numbers = options[:line_numbers] || @profiling
      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
-      @root         = Document.parse(tokenize(source), parse_context)
-      @warnings     = parse_context.warnings
+      @root = Document.parse(tokenize(source), parse_context)
+      @warnings = parse_context.warnings
      self
    end

@@ -146,19 +165,19 @@ module Liquid
    #    filters and tags and might be useful to integrate liquid more with its host application
    #
    def render(*args)
-      return '' if @root.nil?
+      return ''.freeze if @root.nil?

      context = case args.first
      when Liquid::Context
        c = args.shift

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

        c
      when Liquid::Drop
-        drop         = args.shift
+        drop = args.shift
        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
      when Hash
        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
@@ -168,18 +187,11 @@ module Liquid
        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
      end

-      output = nil
-
-      context_register = context.registers.is_a?(StaticRegisters) ? context.registers.static : context.registers
-
      case args.last
      when Hash
        options = args.pop
-        output  = options[:output] if options[:output]

-        options[:registers]&.each do |key, register|
-          context_register[key] = register
-        end
+        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)

        apply_options_to_context(context, options)
      when Module, Array
@@ -192,9 +204,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
@@ -207,10 +220,6 @@ module Liquid
      render(*args)
    end

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

    def tokenize(source)
@@ -221,7 +230,7 @@ module Liquid
      if @profiling && !context.partial
        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)

-        @profiler = Profiler.new(context.template_name)
+        @profiler = Profiler.new
        @profiler.start

        begin
@@ -236,10 +245,10 @@ 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.global_filter = options[:global_filter] if options[:global_filter]
      context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-      context.strict_variables   = options[:strict_variables] if options[:strict_variables]
-      context.strict_filters     = options[:strict_filters] if options[:strict_filters]
+      context.strict_variables = options[:strict_variables] if options[:strict_variables]
+      context.strict_filters = options[:strict_filters] if options[:strict_filters]
    end
  end
 end
--- a/lib/liquid/template_factory.rb
+++ b/lib/liquid/template_factory.rb
@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  class TemplateFactory
-    def for(_template_name)
-      Liquid::Template.new
-    end
-  end
-end
--- a/lib/liquid/tokenizer.rb
+++ b/lib/liquid/tokenizer.rb
@@ -1,37 +1,29 @@
-# frozen_string_literal: true
-
 module Liquid
  class Tokenizer
-    attr_reader :line_number, :for_liquid_tag
+    attr_reader :line_number

-    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
-      @source         = source
-      @line_number    = line_number || (line_numbers ? 1 : nil)
-      @for_liquid_tag = for_liquid_tag
-      @tokens         = tokenize
+    def initialize(source, line_numbers = false)
+      @source = source
+      @line_number = line_numbers ? 1 : nil
+      @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,8 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  module Usage
-    def self.increment(name)
-    end
-  end
-end
--- a/lib/liquid/utils.rb
+++ b/lib/liquid/utils.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  module Utils
    def self.slice_collection(collection, from, to)
@@ -12,7 +10,7 @@ module Liquid

    def self.slice_collection_using_each(collection, from, to)
      segments = []
-      index    = 0
+      index = 0

      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
      if collection.is_a?(String)
@@ -48,11 +46,11 @@ module Liquid
    def self.to_number(obj)
      case obj
      when Float
-        BigDecimal(obj.to_s)
+        BigDecimal.new(obj.to_s)
      when Numeric
        obj
      when String
-        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+        (obj.strip =~ /\A-?\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
      else
        if obj.respond_to?(:to_number)
          obj.to_number
@@ -71,7 +69,7 @@ module Liquid
      end

      case obj
-      when 'now', 'today'
+      when 'now'.freeze, 'today'.freeze
        Time.now
      when /\A\d+\z/, Integer
        Time.at(obj.to_i)
--- a/lib/liquid/variable.rb
+++ b/lib/liquid/variable.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
  # Holds variables. Variables are only loaded "just in time"
  # and are not evaluated as part of the render stage
@@ -12,23 +10,17 @@ 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
-
+    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
    attr_accessor :filters, :name, :line_number
    attr_reader :parse_context
    alias_method :options, :parse_context
-
    include ParserSwitching

    def initialize(markup, parse_context)
-      @markup        = markup
-      @name          = nil
+      @markup  = markup
+      @name    = nil
      @parse_context = parse_context
-      @line_number   = parse_context.line_number
+      @line_number = parse_context.line_number

      parse_with_selected_parser(markup)
    end
@@ -43,17 +35,17 @@ module Liquid

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

-      name_markup   = Regexp.last_match(1)
-      filter_markup = Regexp.last_match(2)
-      @name         = Expression.parse(name_markup)
-      if filter_markup =~ FilterMarkupRegex
-        filters = Regexp.last_match(1).scan(FilterParser)
+      name_markup = $1
+      filter_markup = $2
+      @name = Expression.parse(name_markup)
+      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
@@ -86,50 +78,32 @@ module Liquid
        context.invoke(filter_name, output, *filter_args)
      end

-      context.apply_global_filter(obj)
-    end
+      obj = context.apply_global_filter(obj)

-    def render_to_output_buffer(context, output)
-      obj = render(context)
+      taint_check(context, obj)

-      if obj.is_a?(Array)
-        output << obj.join
-      elsif obj.nil?
-      else
-        output << obj.to_s
-      end
-
-      output
-    end
-
-    def disabled?(_context)
-      false
-    end
-
-    def disabled_tags
-      []
+      obj
    end

    private

    def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args  = []
-      keyword_args = nil
+      filter_args = []
+      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|
@@ -140,9 +114,22 @@ module Liquid
      parsed_args
    end

-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.name] + @node.filters.flatten
+    def taint_check(context, obj)
+      return unless obj.tainted?
+      return if Template.taint_mode == :lax
+
+      @markup =~ QuotedFragment
+      name = Regexp.last_match(0)
+
+      error = TaintedError.new("variable '#{name}' is tainted and was not escaped")
+      error.line_number = line_number
+      error.template_name = context.template_name
+
+      case Template.taint_mode
+      when :warn
+        context.warnings << error
+      when :error
+        raise error
      end
    end
  end
--- a/lib/liquid/variable_lookup.rb
+++ b/lib/liquid/variable_lookup.rb
@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
  class VariableLookup
    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS  = ['size', 'first', 'last'].freeze
+    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]

    attr_reader :name, :lookups

@@ -16,17 +14,17 @@ module Liquid

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

-      @lookups       = lookups
+      @lookups = lookups
      @command_flags = 0

      @lookups.each_index do |i|
        lookup = lookups[i]
        if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse(Regexp.last_match(1))
+          lookups[i] = Expression.parse($1)
        elsif COMMAND_METHODS.include?(lookup)
          @command_flags |= 1 << i
        end
@@ -34,7 +32,7 @@ module Liquid
    end

    def evaluate(context)
-      name   = context.evaluate(@name)
+      name = context.evaluate(@name)
      object = context.find_variable(name)

      @lookups.each_index do |i|
@@ -47,7 +45,7 @@ module Liquid
             (object.respond_to?(:fetch) && key.is_a?(Integer)))

          # if its a proc we will replace the entry with the proc
-          res    = context.lookup_and_evaluate(object, key)
+          res = context.lookup_and_evaluate(object, key)
          object = res.to_liquid

          # Some special cases. If the part wasn't in square brackets and
@@ -80,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,6 +1,4 @@
 # encoding: utf-8
-# frozen_string_literal: true
-
 module Liquid
-  VERSION = "4.0.3"
+  VERSION = "4.0.0"
 end
--- a/liquid.gemspec
+++ b/liquid.gemspec
@@ -1,8 +1,6 @@
 # encoding: utf-8
-# frozen_string_literal: true
-
 lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)

 require "liquid/version"

@@ -17,7 +15,7 @@ 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_ruby_version     = ">= 2.1.0"
  s.required_rubygems_version = ">= 1.3.7"

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

  s.require_path = "lib"

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

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

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

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

  x.report("parse:") { profiler.compile }
-  x.report("render:") { profiler.render }
-  x.report("parse & 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/profile.rb
+++ b/performance/profile.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'stackprof'
 require_relative 'theme_runner'

@@ -15,7 +13,7 @@ profiler.run
    end
  end

-  if profile_type == :cpu && (graph_filename = ENV['GRAPH_FILENAME'])
+  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
    File.open(graph_filename, 'w') do |f|
      StackProf::Report.new(results).print_graphviz(nil, f)
    end
--- a/performance/shopify/comment_form.rb
+++ b/performance/shopify/comment_form.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 class CommentForm < Liquid::Block
  Syntax = /(#{Liquid::VariableSignature}+)/

@@ -7,14 +5,14 @@ class CommentForm < Liquid::Block
    super

    if markup =~ Syntax
-      @variable_name = Regexp.last_match(1)
-      @attributes    = {}
+      @variable_name = $1
+      @attributes = {}
    else
-      raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]"
+      raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
    end
  end

-  def render_to_output_buffer(context, output)
+  def render(context)
    article = context[@variable_name]

    context.stack do
@@ -22,12 +20,10 @@ class CommentForm < Liquid::Block
        'posted_successfully?' => context.registers[:posted_successfully],
        'errors' => context['comment.errors'],
        'author' => context['comment.author'],
-        'email' => context['comment.email'],
-        'body' => context['comment.body'],
+        'email'  => context['comment.email'],
+        'body'   => context['comment.body']
      }
-
-      output << wrap_in_form(article, render_all(@nodelist, context, output))
-      output
+      wrap_in_form(article, render_all(@nodelist, context))
    end
  end

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

 module Database
@@ -18,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
@@ -32,9 +29,9 @@ module Database
      db['article']    = db['blog']['articles'].first

      db['cart']       = {
-        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum + item['line_price'] * item['quantity'] },
-        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum + item['quantity'] },
-        'items' => db['line_items'].values,
+        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
+        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
+        'items'       => db['line_items'].values
      }

      db
@@ -43,6 +40,6 @@ module Database
 end

 if __FILE__ == $PROGRAM_NAME
-  p(Database.tables['collections']['frontpage'].keys)
+  p Database.tables['collections']['frontpage'].keys
  # p Database.tables['blog']['articles']
 end
--- a/performance/shopify/json_filter.rb
+++ b/performance/shopify/json_filter.rb
@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 require 'json'

 module JsonFilter
  def json(object)
-    JSON.dump(object.reject { |k, _v| k == "collections" })
+    JSON.dump(object.reject { |k, v| k == "collections" })
  end
 end
--- a/performance/shopify/liquid.rb
+++ b/performance/shopify/liquid.rb
@@ -1,6 +1,4 @@
-# frozen_string_literal: true
-
-$LOAD_PATH.unshift(__dir__ + '/../../lib')
+$:.unshift __dir__ + '/../../lib'
 require_relative '../../lib/liquid'

 require_relative 'comment_form'
@@ -11,11 +9,11 @@ require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'

-Liquid::Template.register_tag('paginate', Paginate)
-Liquid::Template.register_tag('form', CommentForm)
+Liquid::Template.register_tag 'paginate', Paginate
+Liquid::Template.register_tag 'form', CommentForm

-Liquid::Template.register_filter(JsonFilter)
-Liquid::Template.register_filter(MoneyFilter)
-Liquid::Template.register_filter(WeightFilter)
-Liquid::Template.register_filter(ShopFilter)
-Liquid::Template.register_filter(TagFilter)
+Liquid::Template.register_filter JsonFilter
+Liquid::Template.register_filter MoneyFilter
+Liquid::Template.register_filter WeightFilter
+Liquid::Template.register_filter ShopFilter
+Liquid::Template.register_filter TagFilter
--- a/performance/shopify/money_filter.rb
+++ b/performance/shopify/money_filter.rb
@@ -1,14 +1,12 @@
-# frozen_string_literal: true
-
 module MoneyFilter
  def money_with_currency(money)
    return '' if money.nil?
-    format("$ %.2f USD", money / 100.0)
+    sprintf("$ %.2f USD", money / 100.0)
  end

  def money(money)
    return '' if money.nil?
-    format("$ %.2f", money / 100.0)
+    sprintf("$ %.2f", money / 100.0)
  end

  private
--- a/performance/shopify/paginate.rb
+++ b/performance/shopify/paginate.rb
@@ -1,15 +1,13 @@
-# frozen_string_literal: true
-
 class Paginate < Liquid::Block
-  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/

  def initialize(tag_name, markup, options)
    super

    if markup =~ Syntax
-      @collection_name = Regexp.last_match(1)
-      @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
@@ -19,27 +17,27 @@ class Paginate < Liquid::Block
        @attributes[key] = value
      end
    else
-      raise SyntaxError, "Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number"
+      raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
    end
  end

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

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

      pagination = {
-        'page_size' => @page_size,
-        '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
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module ShopFilter
  def asset_url(input)
    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
@@ -31,7 +29,7 @@ module ShopFilter

  def link_to_vendor(vendor)
    if vendor
-      link_to(vendor, url_for_vendor(vendor), vendor)
+      link_to vendor, url_for_vendor(vendor), vendor
    else
      'Unknown Vendor'
    end
@@ -39,7 +37,7 @@ module ShopFilter

  def link_to_type(type)
    if type
-      link_to(type, url_for_type(type), type)
+      link_to type, url_for_type(type), type
    else
      'Unknown Vendor'
    end
@@ -54,15 +52,15 @@ module ShopFilter
  end

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

    case style
    when 'original'
-      '/files/shops/random_number/' + url
+      return '/files/shops/random_number/' + url
    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
+      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"
    else
      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
    end
@@ -72,14 +70,16 @@ module ShopFilter
    html = []
    html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']

-    paginate['parts'].each do |part|
-      html << if part['is_link']
-        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+    for part in paginate['parts']
+
+      if part['is_link']
+        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
      elsif part['title'].to_i == paginate['current_page'].to_i
-        %(<span class="page current">#{part['title']}</span>)
+        html << %(<span class="page current">#{part['title']}</span>)
      else
-        %(<span class="deco">#{part['title']}</span>)
+        html << %(<span class="deco">#{part['title']}</span>)
      end
+
    end

    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
--- a/performance/shopify/tag_filter.rb
+++ b/performance/shopify/tag_filter.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module TagFilter
  def link_to_tag(label, tag)
    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
@@ -15,11 +13,11 @@ module TagFilter

  def link_to_add_tag(label, tag)
    tags = (@context['current_tags'] + [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
  end

  def link_to_remove_tag(label, tag)
    tags = (@context['current_tags'] - [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
  end
 end
--- a/performance/shopify/weight_filter.rb
+++ b/performance/shopify/weight_filter.rb
@@ -1,8 +1,6 @@
-# frozen_string_literal: true
-
 module WeightFilter
  def weight(grams)
-    format("%.2f", grams / 1000)
+    sprintf("%.2f", grams / 1000)
  end

  def weight_with_unit(grams)
--- a/performance/theme_runner.rb
+++ b/performance/theme_runner.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # This profiler run simulates Shopify.
 # We are looking in the tests directory for liquid files and render them within the designated layout file.
 # We will also export a substantial database to liquid which the templates can render values of.
@@ -23,100 +21,53 @@ class ThemeRunner
    end
  end

-  # Initialize a new liquid ThemeRunner instance
-  # Will load all templates into memory, do this now so that we don't profile IO.
+  # Load all templates into memory, do this now so that
+  # we don't profile IO.
  def initialize
    @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
      next if File.basename(test) == 'theme.liquid'

      theme_path = File.dirname(test) + '/theme.liquid'
-      {
-        liquid: File.read(test),
-        layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
-        template_name: test,
-      }
-    end.compact

-    compile_all_tests
+      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
+    end.compact
  end

-  # `compile` will test just the compilation portion of liquid without any templates
  def compile
-    @tests.each do |test_hash|
-      Liquid::Template.new.parse(test_hash[:liquid])
-      Liquid::Template.new.parse(test_hash[:layout])
+    # Dup assigns because will make some changes to them
+
+    @tests.each do |liquid, layout, template_name|
+      tmpl = Liquid::Template.new
+      tmpl.parse(liquid)
+      tmpl = Liquid::Template.new
+      tmpl.parse(layout)
    end
  end

-  # `run` is called to benchmark rendering and compiling at the same time
  def run
-    each_test do |liquid, layout, assigns, page_template, template_name|
+    # Dup assigns because will make some changes to them
+    assigns = Database.tables.dup
+
+    @tests.each do |liquid, layout, template_name|
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      page_template = File.basename(template_name, File.extname(template_name))
      compile_and_render(liquid, layout, assigns, page_template, template_name)
    end
  end

-  # `render` is called to benchmark just the render portion of liquid
-  def render
-    @compiled_tests.each do |test|
-      tmpl    = test[:tmpl]
-      assigns = test[:assigns]
-      layout  = test[:layout]
-
-      if layout
-        assigns['content_for_layout'] = tmpl.render!(assigns)
-        layout.render!(assigns)
-      else
-        tmpl.render!(assigns)
-      end
-    end
-  end
-
-  private
-
  def compile_and_render(template, layout, assigns, page_template, template_file)
-    compiled_test                 = compile_test(template, layout, assigns, page_template, template_file)
-    assigns['content_for_layout'] = compiled_test[:tmpl].render!(assigns)
-    compiled_test[:layout].render!(assigns) if layout
-  end
+    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))

-  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
+    content_for_layout = tmpl.parse(template).render!(assigns)

    if layout
-      parsed_layout = tmpl.parse(layout)
-      { tmpl: parsed_template, assigns: assigns, layout: parsed_layout }
+      assigns['content_for_layout'] = content_for_layout
+      tmpl.parse(layout).render!(assigns)
    else
-      { tmpl: parsed_template, assigns: assigns }
+      content_for_layout
    end
  end
-
-  # utility method with similar functionality needed in `compile_all_tests` and `run`
-  def each_test
-    # Dup assigns because will make some changes to them
-    assigns = Database.tables.dup
-
-    @tests.each do |test_hash|
-      # Compute page_template outside of profiler run, uninteresting to profiler
-      page_template = File.basename(test_hash[:template_name], File.extname(test_hash[:template_name]))
-      yield(test_hash[:liquid], test_hash[:layout], assigns, page_template, test_hash[:template_name])
-    end
-  end
-
-  # set up a new Liquid::Template object for use in `compile_and_render` and `compile_test`
-  def init_template(page_template, template_file)
-    tmpl                         = Liquid::Template.new
-    tmpl.assigns['page_title']   = 'Page title'
-    tmpl.assigns['template']     = page_template
-    tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
-    tmpl
-  end
 end
--- a/test/integration/assign_test.rb
+++ b/test/integration/assign_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class AssignTest < Minitest::Test
@@ -10,9 +8,9 @@ class AssignTest < Minitest::Test
    {% assign this-thing = 'Print this-thing' %}
    {{ this-thing }}
    END_TEMPLATE
-    template        = Template.parse(template_source)
-    rendered        = template.render!
-    assert_equal("Print this-thing", rendered.strip)
+    template = Template.parse(template_source)
+    rendered = template.render!
+    assert_equal "Print this-thing", rendered.strip
  end

  def test_assigned_variable
--- a/test/integration/blank_test.rb
+++ b/test/integration/blank_test.rb
@@ -1,12 +1,11 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class FoobarTag < Liquid::Tag
-  def render_to_output_buffer(_context, output)
-    output << ' '
-    output
+  def render(*args)
+    " "
  end
+
+  Liquid::Template.register_tag('foobar', FoobarTag)
 end

 class BlankTestFileSystem
@@ -32,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
@@ -96,9 +93,9 @@ class BlankTest < Minitest::Test

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

  def test_case_is_blank
--- a/test/integration/block_test.rb
+++ b/test/integration/block_test.rb
@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class BlockTest < Minitest::Test
-  include Liquid
-
-  def test_unexpected_end_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% if true %}{% endunless %}")
-    end
-    assert_equal(exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif")
-  end
-end
--- a/test/integration/capture_test.rb
+++ b/test/integration/capture_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class CaptureTest < Minitest::Test
@@ -14,9 +12,9 @@ class CaptureTest < Minitest::Test
    {% capture this-thing %}Print this-thing{% endcapture %}
    {{ this-thing }}
    END_TEMPLATE
-    template        = Template.parse(template_source)
-    rendered        = template.render!
-    assert_equal("Print this-thing", rendered.strip)
+    template = Template.parse(template_source)
+    rendered = template.render!
+    assert_equal "Print this-thing", rendered.strip
  end

  def test_capture_to_variable_from_outer_scope_if_existing
@@ -30,9 +28,9 @@ class CaptureTest < Minitest::Test
    {% endif %}
    {{var}}
    END_TEMPLATE
-    template        = Template.parse(template_source)
-    rendered        = template.render!
-    assert_equal("test-string", rendered.gsub(/\s/, ''))
+    template = Template.parse(template_source)
+    rendered = template.render!
+    assert_equal "test-string", rendered.gsub(/\s/, '')
  end

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

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

 class DocumentTest < Minitest::Test
@@ -9,13 +7,13 @@ class DocumentTest < Minitest::Test
    exc = assert_raises(SyntaxError) do
      Template.parse("{% else %}")
    end
-    assert_equal(exc.message, "Liquid syntax error: Unexpected outer 'else' tag")
+    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
  end

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

 class ContextDrop < Liquid::Drop
@@ -33,7 +31,7 @@ class ProductDrop < Liquid::Drop

  class CatchallDrop < Liquid::Drop
    def liquid_method_missing(method)
-      "catchall_method: #{method}"
+      'catchall_method: ' << method.to_s
    end
  end

@@ -49,6 +47,10 @@ class ProductDrop < Liquid::Drop
    ContextDrop.new
  end

+  def user_input
+    "foo".taint
+  end
+
  protected

  def callmenot
@@ -107,61 +109,82 @@ class DropsTest < Minitest::Test

  def test_product_drop
    tpl = Liquid::Template.parse('  ')
-    assert_equal('  ', tpl.render!('product' => ProductDrop.new))
+    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
+  end
+
+  def test_rendering_raises_on_tainted_attr
+    with_taint_mode(:error) do
+      tpl = Liquid::Template.parse('{{ product.user_input }}')
+      assert_raises TaintedError do
+        tpl.render!('product' => ProductDrop.new)
+      end
+    end
+  end
+
+  def test_rendering_warns_on_tainted_attr
+    with_taint_mode(:warn) do
+      tpl = Liquid::Template.parse('{{ product.user_input }}')
+      context = Context.new('product' => ProductDrop.new)
+      tpl.render!(context)
+      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+      assert_equal "variable 'product.user_input' is tainted and was not escaped", context.warnings.first.to_s(false)
+    end
+  end
+
+  def test_rendering_doesnt_raise_on_escaped_tainted_attr
+    with_taint_mode(:error) do
+      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
+      tpl.render!('product' => ProductDrop.new)
+    end
  end

  def test_drop_does_only_respond_to_whitelisted_methods
-    assert_equal("", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new))
-    assert_equal("", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new))
+    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
  end

  def test_drops_respond_to_to_liquid
-    assert_equal("text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new))
-    assert_equal("text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new))
+    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new)
+    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
  end

  def test_text_drop
    output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
-    assert_equal(' text1 ', output)
+    assert_equal ' text1 ', output
  end

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

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

  def test_text_array_drop
    output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
-    assert_equal(' text1  text2 ', output)
+    assert_equal ' text1  text2 ', output
  end

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

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

  def test_protected
    output = Liquid::Template.parse(' {{ product.callmenot }} ').render!('product' => ProductDrop.new)
-    assert_equal('  ', output)
+    assert_equal '  ', output
  end

  def test_object_methods_not_allowed
@@ -172,40 +195,40 @@ class DropsTest < Minitest::Test
  end

  def test_scope
-    assert_equal('1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new))
-    assert_equal('2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-    assert_equal('3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal '1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new)
+    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
  end

  def test_scope_though_proc
-    assert_equal('1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }))
-    assert_equal('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
-    assert_equal('variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new))
-    assert_equal('variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-    assert_equal('test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new))
-    assert_equal('test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new))
+    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
+    assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
  end

  def test_scope_from_tags
-    assert_equal('1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-    assert_equal('12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
-    assert_equal('123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1]))
+    assert_equal '1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
  end

  def test_access_context_from_drop
-    assert_equal('123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3]))
+    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3])
  end

  def test_enumerable_drop
-    assert_equal('123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new))
+    assert_equal '123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
  end

  def test_enumerable_drop_size
-    assert_equal('3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new))
+    assert_equal '3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new)
  end

  def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
@@ -218,16 +241,16 @@ 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)
      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
    end

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

-    [:min, :first].each do |method|
+    [ :min, :first ].each do |method|
      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
@@ -236,22 +259,15 @@ class DropsTest < Minitest::Test
  end

  def test_empty_string_value_access
-    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => ''))
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => '')
  end

  def test_nil_value_access
-    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil))
+    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil)
  end

  def test_default_to_s_on_drops
-    assert_equal('ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new))
-    assert_equal('EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new))
-  end
-
-  def test_invokable_methods
-    assert_equal(%w(to_liquid catchall context texts).to_set, ProductDrop.invokable_methods)
-    assert_equal(%w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods)
-    assert_equal(%w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods)
-    assert_equal(%w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods)
+    assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
+    assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
  end
 end # DropsTest
--- a/test/integration/error_handling_test.rb
+++ b/test/integration/error_handling_test.rb
@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'

 class ErrorHandlingTest < Minitest::Test
@@ -35,31 +33,31 @@ class ErrorHandlingTest < Minitest::Test
    TEXT

    output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
-    assert_equal(expected, output)
+    assert_equal expected, output
  end

  def test_standard_error
    template = Liquid::Template.parse(' {{ errors.standard_error }} ')
-    assert_equal(' Liquid error: standard error ', template.render('errors' => ErrorDrop.new))
+    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)

-    assert_equal(1, template.errors.size)
-    assert_equal(StandardError, template.errors.first.class)
+    assert_equal 1, template.errors.size
+    assert_equal StandardError, template.errors.first.class
  end

  def test_syntax
    template = Liquid::Template.parse(' {{ errors.syntax_error }} ')
-    assert_equal(' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new))
+    assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)

-    assert_equal(1, template.errors.size)
-    assert_equal(SyntaxError, template.errors.first.class)
+    assert_equal 1, template.errors.size
+    assert_equal SyntaxError, template.errors.first.class
  end

  def test_argument
    template = Liquid::Template.parse(' {{ errors.argument_error }} ')
-    assert_equal(' Liquid error: argument error ', template.render('errors' => ErrorDrop.new))
+    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)

-    assert_equal(1, template.errors.size)
-    assert_equal(ArgumentError, template.errors.first.class)
+    assert_equal 1, template.errors.size
+    assert_equal ArgumentError, template.errors.first.class
  end

  def test_missing_endtag_parse_time_error
@@ -78,21 +76,22 @@ class ErrorHandlingTest < Minitest::Test

  def test_lax_unrecognized_operator
    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
-    assert_equal(' Liquid error: Unknown operator =! ', template.render)
-    assert_equal(1, template.errors.size)
-    assert_equal(Liquid::ArgumentError, template.errors.first.class)
+    assert_equal ' Liquid error: Unknown operator =! ', template.render
+    assert_equal 1, template.errors.size
+    assert_equal Liquid::ArgumentError, template.errors.first.class
  end

  def test_with_line_numbers_adds_numbers_to_parser_errors
    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)
@@ -100,14 +99,15 @@ class ErrorHandlingTest < Minitest::Test

  def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
    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)
@@ -122,10 +122,11 @@ class ErrorHandlingTest < Minitest::Test
        bla
            ',
      error_mode: :warn,
-      line_numbers: true)
+      line_numbers: true
+                                     )

-    assert_equal(['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
-      template.warnings.map(&:message))
+    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
+      template.warnings.map(&:message)
  end

  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
@@ -138,10 +139,11 @@ class ErrorHandlingTest < Minitest::Test
          bla
                ',
        error_mode: :strict,
-        line_numbers: true)
+        line_numbers: true
+                            )
    end

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

  def test_syntax_errors_in_nested_blocks_have_correct_line_number
@@ -155,40 +157,41 @@ class ErrorHandlingTest < Minitest::Test

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

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

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

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

  def test_warnings
    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
-    assert_equal(3, template.warnings.size)
-    assert_equal('Unexpected character ~ in "~~~"', template.warnings[0].to_s(false))
-    assert_equal('Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false))
-    assert_equal('Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false))
-    assert_equal('', template.render)
+    assert_equal 3, template.warnings.size
+    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
+    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
+    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
+    assert_equal '', template.render
  end

  def test_warning_line_numbers
    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
-    assert_equal('Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message)
-    assert_equal('Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message)
-    assert_equal('Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message)
-    assert_equal(3, template.warnings.size)
-    assert_equal([1, 2, 3], template.warnings.map(&:line_number))
+    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
+    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
+    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
+    assert_equal 3, template.warnings.size
+    assert_equal [1, 2, 3], template.warnings.map(&:line_number)
  end

  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
@@ -202,47 +205,41 @@ class ErrorHandlingTest < Minitest::Test
  def test_default_exception_renderer_with_internal_error
    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)

-    output = template.render('errors' => ErrorDrop.new)
+    output = template.render({ 'errors' => ErrorDrop.new })

-    assert_equal('This is a runtime error: Liquid error (line 1): internal', output)
-    assert_equal([Liquid::InternalError], template.errors.map(&:class))
+    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
-      ''
-    }
+    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)
+    output = template.render({ 'errors' => ErrorDrop.new })

-    assert_equal('This is a runtime error: ', output)
-    assert_equal([Liquid::ArgumentError], template.errors.map(&:class))
+    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)
+    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
    exceptions = []
-    handler    = ->(e) {
-      exceptions << e
-      e.cause
-    }
+    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 'This is a runtime error: runtime error', output
+    assert_equal [Liquid::InternalError], exceptions.map(&:class)
+    assert_equal exceptions, template.errors
+    assert_equal '#<RuntimeError: runtime error>', exceptions.first.cause.inspect
  end

  class TestFileSystem
-    def read_template_file(_template_path)
+    def read_template_file(template_path)
      "{{ errors.argument_error }}"
    end
  end
@@ -252,13 +249,12 @@ class ErrorHandlingTest < Minitest::Test

    begin
      Liquid::Template.file_system = TestFileSystem.new
-
      template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
-      page     = template.render('errors' => ErrorDrop.new)
+      page = template.render('errors' => ErrorDrop.new)
    ensure
      Liquid::Template.file_system = old_file_system
    end
-    assert_equal("Argument error:\nLiquid error (product line 1): argument error", page)
-    assert_equal("product", template.errors.first.template_name)
+    assert_equal "Argument error:\nLiquid error (product line 1): argument error", page
+    assert_equal "product", template.errors.first.template_name
  end
 end
--- a/test/integration/filter_test.rb
+++ b/test/integration/filter_test.rb
@@ -1,26 +1,24 @@
-# frozen_string_literal: true
-
 require 'test_helper'

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

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

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

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

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

  module OverrideObjectMethodFilter
-    def tap(_input)
+    def tap(input)
      "tap overridden"
    end
  end
@@ -41,13 +39,13 @@ class FiltersTest < Minitest::Test
    @context['var'] = 1000
    @context.add_filters(MoneyFilter)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  def test_compact
-    @context['words']   = ['a', nil, 'b', nil, 'c']
-    @context['hashes']  = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
+    @context['words'] = ['a', nil, 'b', nil, 'c']
+    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]

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

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

    # Test objects
-    assert_equal('A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context))
+    assert_equal 'A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context)
  end

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

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

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

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

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

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

  def test_nonexistent_filter_is_ignored
    @context['var'] = 1000

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

  def test_filter_with_keyword_arguments
    @context['surname'] = 'john'
-    @context['input']   = 'hello %{first_name}, %{last_name}'
+    @context['input'] = 'hello %{first_name}, %{last_name}'
    @context.add_filters(SubstituteFilter)
-    output              = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
-    assert_equal('hello john, doe', output)
+    output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
+    assert_equal 'hello john, doe', output
  end

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

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

@@ -167,8 +165,8 @@ class FiltersInTemplate < Minitest::Test
  end

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

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

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

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

--- a/test/integration/output_test.rb
+++ b/test/integration/output_test.rb
@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 require 'test_helper'

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

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

@@ -42,84 +40,84 @@ class OutputTest < Minitest::Test
    text = %( {{best_cars}} )

    expected = %( bmw )
-    assert_equal(expected, Template.parse(text).render!(@assigns))
+    assert_equal expected, Template.parse(text).render!(@assigns)
  end

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

  def test_variable_traversing
    text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )

    expected = %( good bad good )
-    assert_equal(expected, Template.parse(text).render!(@assigns))
+    assert_equal expected, Template.parse(text).render!(@assigns)
  end

  def test_variable_piping
-    text     = %( {{ car.gm | make_funny }} )
+    text = %( {{ car.gm | make_funny }} )
    expected = %( LOL )

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

  def test_variable_piping_with_input
-    text     = %( {{ car.gm | cite_funny }} )
+    text = %( {{ car.gm | cite_funny }} )
    expected = %( LOL: bad )

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

  def test_variable_piping_with_args
-    text     = %! {{ car.gm | add_smiley : ':-(' }} !
+    text = %! {{ car.gm | add_smiley : ':-(' }} !
    expected = %| bad :-( |

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

  def test_variable_piping_with_no_args
-    text     = %( {{ car.gm | add_smiley }} )
+    text = %( {{ car.gm | add_smiley }} )
    expected = %| bad :-) |

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

  def test_multiple_variable_piping_with_args
-    text     = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
+    text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
    expected = %| bad :-( :-( |

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

  def test_variable_piping_with_multiple_args
-    text     = %( {{ car.gm | add_tag : 'span', 'bar'}} )
+    text = %( {{ car.gm | add_tag : 'span', 'bar'}} )
    expected = %( <span id="bar">bad</span> )

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

  def test_variable_piping_with_variable_args
-    text     = %( {{ car.gm | add_tag : 'span', car.bmw}} )
+    text = %( {{ car.gm | add_tag : 'span', car.bmw}} )
    expected = %( <span id="good">bad</span> )

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

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

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

  def test_link_to
-    text     = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
+    text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
    expected = %( <a href="http://typo.leetsoft.com">Typo</a> )

-    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
  end
 end # OutputTest
--- a/Show More
+++ b/Show More