Also dump object distribution

Lazy init context errors and interrupts to prevent excess allocation
Reuse filters array during variable parsing
2026-01-02 08:15:41 +03:00 · 2015-05-06 10:45:20 -04:00 · 2015-05-05 23:40:52 -04:00 · 2015-05-05 23:30:05 -04:00 · 2015-05-05 23:21:28 -04:00 · 2015-05-05 23:02:08 -04:00
152 changed files with 3545 additions and 8925 deletions
--- a/.github/probots.yml
+++ b/.github/probots.yml
@@ -1,2 +0,0 @@
 enabled:
  - cla
--- a/.gitignore
+++ b/.gitignore
@@ -6,5 +6,3 @@ pkg
 .rvmrc
 .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 +0,0 @@
 inherit_from:
  - 'https://shopify.github.io/ruby-style-guide/rubocop.yml'
  - .rubocop_todo.yml
 require: rubocop-performance
 Performance:
  Enabled: true
 AllCops:
  TargetRubyVersion: 2.4
  Exclude:
    - 'vendor/bundle/**/*'
 Naming/MethodName:
  Exclude:
    - 'example/server/liquid_servlet.rb'
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -1,48 +0,0 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
 # on 2019-09-11 06:34:25 +1000 using RuboCop version 0.74.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: 98
 # Cop supports --auto-correct.
 # Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
 Layout/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: 5
 Style/ClassVars:
  Exclude:
    - 'lib/liquid/condition.rb'
    - 'lib/liquid/strainer.rb'
    - 'lib/liquid/template.rb'
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,26 +1,20 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.4
+  - 2.0
-  - 2.5
+  - 2.1
-  - 2.6
+  - 2.2
  - &latest_ruby 2.7
  - ruby-head
  - jruby-head
  - rbx-2
 sudo: false
 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:
+script: "rake test"
  only:
    - master
    - gh-pages
    - /.*-stable/
 notifications:
  disable: true
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,22 +4,23 @@
 * Bugfixes
 * Performance improvements
-* Features that are likely to be useful to the majority of Liquid users
+* Features which are likely to be useful to the majority of Liquid users
 ## Things we won't merge
-* Code that introduces considerable performance degrations
+* Code which introduces considerable performance degrations
-* Code that touches performance-critical parts of Liquid and comes without benchmarks
+* Code which touches performance critical parts of Liquid and comes without benchmarks
-* Features that are not important for most people (we want to keep the core Liquid code small and tidy)
+* Features which are not important for most people (we want to keep the core Liquid code small and tidy)
-* Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
+* Features which can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
-* Code that does not include tests
+* Code which comes without tests
-* Code that breaks existing tests
+* Code which breaks existing tests
 ## Workflow
 * Fork the Liquid repository
 * Create a new branch in your fork
-* If it makes sense, add tests for your code and/or run a performance benchmark
+* If it makes sense, add tests for your code and run a performance benchmark
-* Make sure all tests pass (`bundle exec rake`)
+* Make sure all tests pass
 * Create a pull request
 * In the description, ping one of [@boourns](https://github.com/boourns), [@fw42](https://github.com/fw42), [@camilo](https://github.com/camilo), [@dylanahsmith](https://github.com/dylanahsmith), or [@arthurnn](https://github.com/arthurnn) and ask for a code review.
--- a/25
+++ b/25
@@ -1,27 +1,10 @@
 # frozen_string_literal: true
 source 'https://rubygems.org'
 git_source(:github) do |repo_name|
  "https://github.com/#{repo_name}.git"
 end
 gemspec
-
+gem 'stackprof', platforms: :mri_21
-group :benchmark, :test do
+gem 'allocation_tracer', platforms: :mri_21
  gem 'benchmark-ips'
  gem 'memory_profiler'
  gem 'terminal-table'
  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
    gem 'stackprof'
  end
 end
 group :test do
-  gem 'rubocop', '~> 0.78.0', require: false
+  gem 'spy', '0.4.1'
-  gem 'rubocop-performance', require: false
+  gem 'benchmark-ips'
  platform :mri, :truffleruby do
    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
  end
 end
--- a/History.md
+++ b/History.md
@@ -1,122 +1,23 @@
 # Liquid Change Log
-### Unreleased
+## 4.0.0 / not yet released / branch "master"
 * 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 forloop.parentloop as a reference to the parent loop (#520) [Justin Li, pushrax]
-* Add `ParseTreeVisitor` to iterate the Liquid AST (#1025) [Stephen Paul Weber]
+* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith, dylanahsmith]
-* Improve `strip_html` performance (#1032) [printercu]
+* Add concat filter to concatenate arrays (#429) [Diogo Beato, dvbeato]
 * Ruby 1.9 support dropped (#491) [Justin Li, pushrax]
 * Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith, sunblaze]
 ### Fixed
-* Add error checking for invalid combinations of inputs to sort, sort_natural, where, uniq, map, compact filters (#1059) [Garland Zhang]
+* Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten, fw42]
-* Validate the character encoding in url_decode (#1070) [Clayton Smith]
+* Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds, kreynolds]
 * Disallow filters with no variable in strict mode (#475) [Justin Li, pushrax]
 * Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li, pushrax]
 * Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li, pushrax]
-## 4.0.1 / 2018-10-09
+## 3.0.2 / 2015-04-24 / branch "3-0-stable"
-### Changed
+* Expose VariableLookup private members (#551) [Justin Li, pushrax]
 * Add benchmark group in Gemfile (#855) [Jerry Liu]
 * Allow benchmarks to benchmark render by itself (#851) [Jerry Liu]
 * Avoid calling `line_number` on String node when rescuing a render error. (#860) [Dylan Thacker-Smith]
 * Avoid duck typing to detect whether to call render on a node. [Dylan Thacker-Smith]
 * Clarify spelling of `reversed` on `for` block tag (#843) [Mark Crossfield]
 * Replace recursion with loop to avoid potential stack overflow from malicious input (#891, #892) [Dylan Thacker-Smith]
 * Limit block tag nesting to 100 (#894) [Dylan Thacker-Smith]
 * Replace `assert_equal nil` with `assert_nil` (#895) [Dylan Thacker-Smith]
 * Remove Spy Gem (#896) [Dylan Thacker-Smith]
 * Add `collection_name` and `variable_name` reader to `For` block (#909)
 * Symbols render as strings (#920) [Justin Li]
 * Remove default value from Hash objects (#932) [Maxime Bedard]
 * Remove one level of nesting (#944) [Dylan Thacker-Smith]
 * Update Rubocop version (#952) [Justin Li]
 * Add `at_least` and `at_most` filters (#954, #958) [Nithin Bekal]
 * Add a regression test for a liquid-c trim mode bug (#972) [Dylan Thacker-Smith]
 * Use https rather than git protocol to fetch liquid-c [Dylan Thacker-Smith]
 * Add tests against Ruby 2.4 (#963) and 2.5 (#981)
 * Replace RegExp literals with constants (#988) [Ashwin Maroli]
 * Replace unnecessary `#each_with_index` with `#each` (#992) [Ashwin Maroli]
 * Improve the unexpected end delimiter message for block tags. (#1003) [Dylan Thacker-Smith]
 * Refactor and optimize rendering (#1005) [Christopher Aue]
 * Add installation instruction (#1006) [Ben Gift]
 * Remove Circle CI (#1010)
 * Rename deprecated `BigDecimal.new` to `BigDecimal` (#1024) [Koichi ITO]
 * Rename deprecated Rubocop name (#1027) [Justin Li]
 ### Fixed
 * Handle `join` filter on non String joiners (#857) [Richard Monette]
 * Fix duplicate inclusion condition logic error of `Liquid::Strainer.add_filter` method (#861)
 * Fix `escape`, `url_encode`, `url_decode` not handling non-string values (#898) [Thierry Joyal]
 * Fix raise when variable is defined but nil when using `strict_variables` [Pascal Betz]
 * Fix `sort` and `sort_natural` to handle arrays with nils (#930) [Eric Chan]
 ## 4.0.0 / 2016-12-14 / branch "4-0-stable"
 ### Changed
 * Render an opaque internal error by default for non-Liquid::Error (#835) [Dylan Thacker-Smith]
 * Ruby 2.0 support dropped (#832) [Dylan Thacker-Smith]
 * Add to_number Drop method to allow custom drops to work with number filters (#731)
 * Add strict_variables and strict_filters options to detect undefined references (#691)
 * Improve loop performance (#681) [Florian Weingarten]
 * Rename Drop method `before_method` to `liquid_method_missing` (#661) [Thierry Joyal]
 * Add url_decode filter to invert url_encode (#645) [Larry Archer]
 * Add global_filter to apply a filter to all output (#610) [Loren Hale]
 * Add compact filter (#600) [Carson Reinke]
 * Rename deprecated "has_key?" and "has_interrupt?" methods (#593) [Florian Weingarten]
 * Include template name with line numbers in render errors (574) [Dylan Thacker-Smith]
 * Add sort_natural filter (#554) [Martin Hanzel]
 * Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li]
 * Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith]
 * Add concat filter to concatenate arrays (#429) [Diogo Beato]
 * Ruby 1.9 support dropped (#491) [Justin Li]
 * Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith]
 * Remove `liquid_methods` (See https://github.com/Shopify/liquid/pull/568 for replacement)
 * Liquid::Template.register_filter raises when the module overrides registered public methods as private or protected (#705) [Gaurav Chande]
 ### Fixed
 * Fix variable names being detected as an operator when starting with contains (#788) [Michael Angell]
 * Fix include tag used with strict_variables (#828) [QuickPay]
 * Fix map filter when value is a Proc (#672) [Guillaume Malette]
 * Fix truncate filter when value is not a string (#672) [Guillaume Malette]
 * Fix behaviour of escape filter when input is nil (#665) [Tanel Jakobsoo]
 * Fix sort filter behaviour with empty array input (#652) [Marcel Cary]
 * Fix test failure under certain timezones (#631) [Dylan Thacker-Smith]
 * Fix bug in uniq filter (#595) [Florian Weingarten]
 * Fix bug when "blank" and "empty" are used as variable names (#592) [Florian Weingarten]
 * Fix condition parse order in strict mode (#569) [Justin Li]
 * Fix naming of the "context variable" when dynamically including a template (#559) [Justin Li]
 * Gracefully accept empty strings in the date filter (#555) [Loren Hale]
 * Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten]
 * Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds]
 * Disallow filters with no variable in strict mode (#475) [Justin Li]
 * Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li]
 * Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li]
 ## 3.0.5 / 2015-07-23 / branch "3-0-stable"
 * Fix test failure under certain timezones [Dylan Thacker-Smith]
 ## 3.0.4 / 2015-07-17
 * Fix chained access to multi-dimensional hashes [Florian Weingarten]
 ## 3.0.3 / 2015-05-28
 * Fix condition parse order in strict mode (#569) [Justin Li]
 ## 3.0.2 / 2015-04-24
 * Expose VariableLookup private members (#551) [Justin Li]
 * Documentation fixes
 ## 3.0.1 / 2015-01-23
@@ -125,52 +26,44 @@
 ## 3.0.0 / 2014-11-12
-* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith]
+* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith, dylanahsmith]
 * Fixed condition with wrong data types (#423) [Bogdan Gusiev]
-* Add url_encode to standard filters (#421) [Derrick Reimer]
+* Add url_encode to standard filters (#421) [Derrick Reimer, djreimer]
-* Add uniq to standard filters [Florian Weingarten]
+* Add uniq to standard filters [Florian Weingarten, fw42]
-* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, Florian Weingarten]
+* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge]
+* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
-* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge]
+* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
-* Properly set context rethrow_errors on render! #349 [Thierry Joyal]
+* Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
-* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten]
+* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten, fw42]
-* Remove ActionView template handler [Dylan Thacker-Smith]
+* Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
-* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten]
+* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten, fw42]
-* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith]
+* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith, dylanahsmith]
-* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith]
+* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith, dylanahsmith]
-* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev]
+* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
-* Add a to_s default for liquid drops (#306) [Adam Doeler]
+* Add a to_s default for liquid drops (#306) [Adam Doeler, releod]
-* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten]
+* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
-* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones]
+* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones, dntj]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
+* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten]
+* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten, fw42]
-* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi]
+* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi, agladkyi]
-* Allow drops to optimize loading a slice of elements (#282) [Tom Burns]
+* Allow drops to optimize loading a slice of elements (#282) [Tom Burns, boourns]
-* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink]
+* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink, joost]
-* Add a class cache to avoid runtime extend calls (#249) [James Tucker]
+* Add a class cache to avoid runtime extend calls (#249) [James Tucker, raggi]
-* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten]
+* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten, fw42]
-* Add default filter to standard filters (#267) [Derrick Reimer]
+* Add default filter to standard filters (#267) [Derrick Reimer, djreimer]
-* Add optional strict parsing and warn parsing (#235) [Tristan Hume]
+* Add optional strict parsing and warn parsing (#235) [Tristan Hume, trishume]
 * Add I18n syntax error translation (#241) [Simon Hørup Eskildsen, Sirupsen]
-* Make sort filter work on enumerable drops (#239) [Florian Weingarten]
+* Make sort filter work on enumerable drops (#239) [Florian Weingarten, fw42]
-* Fix clashing method names in enumerable drops (#238) [Florian Weingarten]
+* Fix clashing method names in enumerable drops (#238) [Florian Weingarten, fw42]
-* Make map filter work on enumerable drops (#233) [Florian Weingarten]
+* Make map filter work on enumerable drops (#233) [Florian Weingarten, fw42]
-* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten]
+* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
-## 2.6.3 / 2015-07-23 / branch "2-6-stable"
+## 2.6.1 / 2014-01-10 / branch "2-6-stable"
 * Fix test failure under certain timezones [Dylan Thacker-Smith]
 ## 2.6.2 / 2015-01-23
 * Remove duplicate hash key [Parker Moore]
 ## 2.6.1 / 2014-01-10
 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
+* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
 ## 2.6.0 / 2013-11-25
@@ -178,37 +71,37 @@ IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains
 The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are likely to break on Ruby 1.8.
 * Bugfix for #106: fix example servlet [gnowoel]
-* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss]
+* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
-* Bugfix for #114: strip_html filter supports style tags [James Allardice]
+* Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]
-* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup]
+* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup, ndwebgroup]
-* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten]
+* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten, fw42]
-* Bugfix for #204: 'raw' parsing bug [Florian Weingarten]
+* Bugfix for #204: 'raw' parsing bug [Florian Weingarten, fw42]
-* Bugfix for #150: 'for' parsing bug [Peter Schröder]
+* Bugfix for #150: 'for' parsing bug [Peter Schröder, phoet]
-* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder]
+* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder, phoet]
-* Bugfix for #174, "can't convert Fixnum into String" for "replace" [jsw0528]
+* Bugfix for #174, "can't convert Fixnum into String" for "replace" [wǒ_is神仙, jsw0528]
-* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep]
+* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep, darkhelmet]
-* Resource limits [Florian Weingarten]
+* Resource limits [Florian Weingarten, fw42]
-* Add reverse filter [Jay Strybis]
+* Add reverse filter [Jay Strybis, unreal]
 * Add utf-8 support
-* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos]
+* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos, astathopoulos]
-* Cache tokenized partial templates [Tom Burns]
+* Cache tokenized partial templates [Tom Burns, boourns]
-* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer]
+* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer, stomar]
-* Better documentation for 'include' tag (closes #163) [Peter Schröder]
+* Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
-* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves]
+* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]
 ## 2.5.5 / 2014-01-10 / branch "2-5-stable"
 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
+* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
 ## 2.5.4 / 2013-11-11
-* Fix "can't convert Fixnum into String" for "replace" (#173), [jsw0528]
+* Fix "can't convert Fixnum into String" for "replace" (#173), [wǒ_is神仙, jsw0528]
 ## 2.5.3 / 2013-10-09
-* #232, #234, #237: Fix map filter bugs [Florian Weingarten]
+* #232, #234, #237: Fix map filter bugs [Florian Weingarten, fw42]
 ## 2.5.2 / 2013-09-03 / deleted
@@ -216,7 +109,7 @@ Yanked from rubygems, as it contained too many changes that broke compatibility.
 ## 2.5.1 / 2013-07-24
-* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten]
+* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten, fw42]
 ## 2.5.0 / 2013-03-06
--- a/0
+++ b/0
--- a/README.md
+++ b/README.md
@@ -42,8 +42,6 @@ Liquid is a template engine which was written with very specific requirements:
 ## How to use Liquid
 Install Liquid by adding `gem 'liquid'` to your gemfile.
 Liquid supports a very simple API based around the Liquid::Template class.
 For standard use you can just pass it the content of a file and call render with a parameters hash.
@@ -75,40 +73,3 @@ This is useful for doing things like enabling strict mode only in the theme edit
 It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
 It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
 ### Undefined variables and filters
 By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.
 You can improve this situation by passing `strict_variables: true` and/or `strict_filters: true` options to the `render` method.
 When one of these options is set to true, all errors about undefined variables and undefined filters will be stored in `errors` array of a `Liquid::Template` instance.
 Here are some examples:
 ```ruby
 template = Liquid::Template.parse("{{x}} {{y}} {{z.a}} {{z.b}}")
 template.render({ 'x' => 1, 'z' => { 'a' => 2 } }, { strict_variables: true })
 #=> '1  2 ' # when a variable is undefined, it's rendered as nil
 template.errors
 #=> [#<Liquid::UndefinedVariable: Liquid error: undefined variable y>, #<Liquid::UndefinedVariable: Liquid error: undefined variable b>]
 ```
 ```ruby
 template = Liquid::Template.parse("{{x | filter1 | upcase}}")
 template.render({ 'x' => 'foo' }, { strict_filters: true })
 #=> '' # when at least one filter in the filter chain is undefined, a whole expression is rendered as nil
 template.errors
 #=> [#<Liquid::UndefinedFilter: Liquid error: undefined filter filter1>]
 ```
 If you want to raise on a first exception instead of pushing all of them in `errors`, you can use `render!` method:
 ```ruby
 template = Liquid::Template.parse("{{x}} {{y}}")
 template.render!({ 'x' => 1}, { strict_variables: true })
 #=> Liquid::UndefinedVariable: Liquid error: undefined variable y
 ```
 ### Usage tracking
 To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
 Once you have enabled usage tracking, we recommend reporting any events through Github Issues that your system may be logging. It is highly likely this event has been added to consider deprecating or improving code specific to this event, so please raise any concerns.
--- a/63
+++ b/63
@@ -1,64 +1,42 @@
 # frozen_string_literal: true
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"
-task(default: [:test, :rubocop])
+task :default => 'test'
-desc('run test suite with default parser')
+desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
  t.libs << '.' << 'lib' << 'test'
  t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
  t.verbose = false
 end
-desc('run test suite with warn error mode')
+desc 'run test suite with warn error mode'
 task :warn_test do
  ENV['LIQUID_PARSER_MODE'] = 'warn'
  Rake::Task['base_test'].invoke
 end
-task :rubocop do
+desc 'runs test suite with both strict and lax parsers'
  if RUBY_ENGINE == 'ruby'
    require 'rubocop/rake_task'
    RuboCop::RakeTask.new
  end
 end
 desc('runs test suite with both strict and lax parsers')
 task :test do
  ENV['LIQUID_PARSER_MODE'] = 'lax'
  Rake::Task['base_test'].invoke
  ENV['LIQUID_PARSER_MODE'] = 'strict'
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke
  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
    ENV['LIQUID_C'] = '1'
    ENV['LIQUID_PARSER_MODE'] = 'lax'
    Rake::Task['base_test'].reenable
    Rake::Task['base_test'].invoke
  ENV['LIQUID_PARSER_MODE'] = 'strict'
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke
 end
 end
-task(gem: :build)
+task :gem => :build
 task :build do
  system "gem build liquid.gemspec"
 end
-task install: :build do
+task :install => :build do
  system "gem install liquid-#{Liquid::VERSION}.gem"
 end
-task release: :build do
+task :release => :build do
  system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'"
  system "git push --tags"
  system "gem push liquid-#{Liquid::VERSION}.gem"
@@ -66,6 +44,7 @@ task release: :build do
 end
 namespace :benchmark do
  desc "Run the liquid benchmark with lax parsing"
  task :run do
    ruby "./performance/benchmark.rb lax"
@@ -77,7 +56,9 @@ namespace :benchmark do
  end
 end
 namespace :profile do
  desc "Run the liquid profile/performance coverage"
  task :run do
    ruby "./performance/profile.rb"
@@ -87,20 +68,24 @@ namespace :profile do
  task :strict do
    ruby "./performance/profile.rb strict"
  end
 end
-namespace :memory_profile do
+namespace :memory do
-  desc "Run memory profiler"
+
  desc "Run the liquid memory tracer"
  task :run do
-    ruby "./performance/memory_profile.rb"
+    ruby "./performance/memory.rb"
  end
  end
-desc("Run example")
+  desc "Run the liquid memory tracer with strict parsing"
  task :strict do
    ruby "./performance/memory.rb strict"
  end
 end
 desc "Run example"
 task :example do
  ruby "-w -d -Ilib example/server/server.rb"
 end
 task :console do
  exec 'irb -I lib -r liquid'
 end
--- 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)
@@ -19,6 +17,7 @@ module ProductsFilter
 end
 class Servlet < LiquidServlet
  def index
    { 'date' => Time.now }
  end
@@ -43,4 +42,5 @@ class Servlet < LiquidServlet
  def description
    "List of Products ~ This is a list of products with price and description."
  end
 end
--- a/example/server/liquid_servlet.rb
+++ b/example/server/liquid_servlet.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
  def do_GET(req, res)
    handle(:get, req, res)
  end
@@ -11,20 +10,20 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
  private
-  def handle(_type, req, res)
+  def handle(type, req, res)
    @request = req
    @response = res
    @request.path_info =~ /(\w+)\z/
-    @action  = Regexp.last_match(1) || 'index'
+    @action = $1 || 'index'
    @assigns = send(@action) if respond_to?(@action)
    @response['Content-Type'] = "text/html"
    @response.status = 200
-    @response.body   = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
+    @response.body = Liquid::Template.parse(read_template).render(@assigns, :filters => [ProductsFilter])
  end
  def read_template(filename = @action)
-    File.read("#{__dir__}/templates/#{filename}.liquid")
+    File.read( File.dirname(__FILE__) + "/templates/#{filename}.liquid" )
  end
 end
--- a/example/server/server.rb
+++ b/example/server/server.rb
@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 require 'webrick'
 require 'rexml/document'
-require_relative '../../lib/liquid'
+DIR = File.expand_path(File.dirname(__FILE__))
-require_relative 'liquid_servlet'
+
-require_relative 'example_servlet'
+require DIR + '/../../lib/liquid'
 require DIR + '/liquid_servlet'
 require DIR + '/example_servlet'
 # Setup webrick
-server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
+server = WEBrick::HTTPServer.new( :Port => ARGV[1] || 3000 )
 server.mount('/', Servlet)
 trap("INT"){ server.shutdown }
 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,9 @@
 module Liquid
  FilterSeparator             = /\|/
-  ArgumentSeparator           = ','
+  ArgumentSeparator           = ','.freeze
-  FilterArgumentSeparator     = ':'
+  FilterArgumentSeparator     = ':'.freeze
-  VariableAttributeSeparator  = '.'
+  VariableAttributeSeparator  = '.'.freeze
  WhitespaceControl           = '-'
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -37,7 +34,7 @@ module Liquid
  QuotedString                = /"[^"]*"|'[^']*'/
  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
+  AnyStartingTag              = /\{\{|\{\%/
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
@@ -47,24 +44,18 @@ module Liquid
 end
 require "liquid/version"
 require 'liquid/parse_tree_visitor'
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
 require 'liquid/drop'
 require 'liquid/tablerowloop_drop'
 require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer_factory'
+require 'liquid/strainer'
 require 'liquid/strainer_template'
 require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
 require 'liquid/tag/disabler'
 require 'liquid/tag/disableable'
 require 'liquid/block'
 require 'liquid/block_body'
 require 'liquid/document'
@@ -76,15 +67,10 @@ require 'liquid/resource_limits'
 require 'liquid/template'
 require 'liquid/standardfilters'
 require 'liquid/condition'
 require 'liquid/module_ex'
 require 'liquid/utils'
-require 'liquid/tokenizer'
+require 'liquid/token'
 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
 #
-Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
--- a/lib/liquid/block.rb
+++ b/lib/liquid/block.rb
@@ -1,21 +1,16 @@
 # frozen_string_literal: true
 module Liquid
  class Block < Tag
    MAX_DEPTH = 100
    def initialize(tag_name, markup, options)
      super
      @blank = true
    end
    def parse(tokens)
-      @body = new_body
+      @body = BlockBody.new
-      while parse_body(@body, tokens)
+      while more = parse_body(@body, tokens)
      end
    end
    # For backwards compatibility
    def render(context)
      @body.render(context)
    end
@@ -28,22 +23,29 @@ module Liquid
      @body.nodelist
    end
-    def unknown_tag(tag_name, _markup, _tokenizer)
+    # warnings of this block and all sub-tags
-      Block.raise_unknown_tag(tag_name, block_name, block_delimiter, parse_context)
+    def warnings
      all_warnings = []
      all_warnings.concat(@warnings) if @warnings
      (nodelist || []).each do |node|
        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
      end
-    # @api private
+      all_warnings
-    def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
+    end
-      if tag == 'else'
+
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else",
+    def unknown_tag(tag, params, tokens)
-          block_name: block_name)
+      case tag
-      elsif tag.start_with?('end')
+      when 'else'.freeze
-        raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter",
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
-          tag: tag,
+                                                 :block_name => block_name))
-          block_name: block_name,
+      when 'end'.freeze
-          block_delimiter: block_delimiter)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
                                                 :block_name => block_name,
                                                 :block_delimiter => block_delimiter))
      else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
      end
    end
@@ -55,35 +57,21 @@ module Liquid
      @block_delimiter ||= "end#{block_name}"
    end
-    private
+    protected
    # @api public
    def new_body
      parse_context.new_block_body
    end
    # @api public
    def parse_body(body, tokens)
-      if parse_context.depth >= MAX_DEPTH
+      body.parse(tokens, options) do |end_tag_name, end_tag_params|
        raise StackLevelError, "Nesting too deep"
      end
      parse_context.depth += 1
      begin
        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
        @blank &&= body.blank?
        return false if end_tag_name == block_delimiter
        unless end_tag_name
-            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+          raise SyntaxError.new(@options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
        end
        # this tag is not registered with the system
        # pass it to the current block for special handling or error reporting
        unknown_tag(end_tag_name, end_tag_params, tokens)
      end
      ensure
        parse_context.depth -= 1
      end
      true
    end
--- a/lib/liquid/block_body.rb
+++ b/lib/liquid/block_body.rb
@@ -1,15 +1,9 @@
 # frozen_string_literal: true
 require 'English'
 module Liquid
  class BlockBody
-    LiquidTagToken      = /\A\s*(\w+)\s*(.*?)\z/o
+    FullToken = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    FullToken           = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    ContentOfVariable   = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    TAGSTART = "{%".freeze
-    WhitespaceOrNothing = /\A\s*\z/
+    VARSTART = "{{".freeze
    TAGSTART            = "{%"
    VARSTART            = "{{"
    attr_reader :nodelist
@@ -18,227 +12,121 @@ module Liquid
      @blank = true
    end
-    def parse(tokenizer, parse_context, &block)
+    def parse(tokens, options)
-      parse_context.line_number = tokenizer.line_number
+      while token = tokens.shift
-
+        begin
-      if tokenizer.for_liquid_tag
+          unless token.empty?
        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
          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
    # @api private
    def self.raise_missing_tag_terminator(token, parse_context)
      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
    end
    # @api private
    def self.raise_missing_variable_terminator(token, parse_context)
      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
    end
    # @api private
    def self.render_node(context, output, node)
      node.render_to_output_buffer(context, output)
    rescue => exc
      blank_tag = !node.instance_of?(Variable) && node.blank?
      rescue_render_node(context, output, node.line_number, exc, blank_tag)
    end
    # @api private
    def self.rescue_render_node(context, output, line_number, exc, blank_tag)
      case exc
      when MemoryError
        raise
      when UndefinedVariable, UndefinedDropMethod, UndefinedFilter
        context.handle_error(exc, line_number)
      else
        error_message = context.handle_error(exc, line_number)
        unless blank_tag # conditional for backwards compatibility
          output << error_message
        end
      end
    end
    private def parse_liquid_tag(markup, parse_context)
      liquid_tag_tokenizer = 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)
+              if token =~ FullToken
-          unless token =~ FullToken
+                tag_name = $1
-            BlockBody.raise_missing_tag_terminator(token, parse_context)
+                markup = $2
-          end
+                # fetch the tag from registered blocks
-          tag_name = Regexp.last_match(2)
+                if tag = Template.tags[tag_name]
-          markup   = Regexp.last_match(4)
+                  markup = token.child(markup) if token.is_a?(Token)
-
+                  new_tag = tag.parse(tag_name, markup, tokens, options)
-          if parse_context.line_number
+                  new_tag.line_number = token.line_number if token.is_a?(Token)
-            # newlines inside the tag should increase the line number,
+                  @blank &&= new_tag.blank?
-            # particularly important for multiline {% liquid %} tags
+                  @nodelist << new_tag
-            parse_context.line_number += Regexp.last_match(1).count("\n") + Regexp.last_match(3).count("\n")
+                else
          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)
+              else
-          @blank &&= new_tag.blank?
+                raise_missing_tag_terminator(token, options)
-          @nodelist << new_tag
+              end
            when token.start_with?(VARSTART)
-          whitespace_handler(token, parse_context)
+              new_var = create_variable(token, options)
-          @nodelist << create_variable(token, parse_context)
+              new_var.line_number = token.line_number if token.is_a?(Token)
              @nodelist << new_var
              @blank = false
            else
          if parse_context.trim_whitespace
            token.lstrip!
          end
          parse_context.trim_whitespace = false
              @nodelist << token
-          @blank &&= !!(token =~ WhitespaceOrNothing)
+              @blank &&= !!(token =~ /\A\s*\z/)
            end
          end
        rescue SyntaxError => e
          e.set_line_number_from_token(token)
          raise
        end
        parse_context.line_number = tokenizer.line_number
      end
      yield nil, nil
    end
    def whitespace_handler(token, parse_context)
      if token[2] == WhitespaceControl
        previous_token = @nodelist.last
        if previous_token.is_a?(String)
          first_byte = previous_token.getbyte(0)
          previous_token.rstrip!
          if previous_token.empty? && parse_context[:bug_compatible_whitespace_trimming] && first_byte
            previous_token << first_byte
          end
        end
      end
      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
    end
    def blank?
      @blank
    end
-    # Remove blank strings in the block body for a control flow tag (e.g. `if`, `for`, `case`, `unless`)
+    def warnings
-    # with a blank body.
+      all_warnings = []
-    #
+      nodelist.each do |node|
-    # For example, in a conditional assignment like the following
+        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
-    #
+      end
-    # ```
+      all_warnings
    # {% if size > max_size %}
    #   {% assign size = max_size %}
    # {% endif %}
    # ```
    #
    # we assume the intention wasn't to output the blank spaces in the `if` tag's block body, so this method
    # will remove them to reduce the render output size.
    #
    # Note that it is now preferred to use the `liquid` tag for this use case.
    def remove_blank_strings
      raise "remove_blank_strings only support being called on a blank block body" unless @blank
      @nodelist.reject! { |node| node.instance_of?(String) }
    end
    def render(context)
-      render_to_output_buffer(context, +'')
+      @output ||= []
-    end
+      @output.clear
      context.resource_limits.render_score += @nodelist.length
-    def render_to_output_buffer(context, output)
+      @nodelist.each do |token|
-      context.resource_limits.increment_render_score(@nodelist.length)
+        # Break out if we have any unhanded interrupts.
        break if context.has_interrupt?
-      idx = 0
+        begin
      while (node = @nodelist[idx])
        if node.instance_of?(String)
          output << node
        else
          render_node(context, output, node)
          # If we get an Interrupt that means the block must stop processing. An
          # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}. These tags may also occur through Block or Include tags.
+          # or {% continue %}
-          break if context.interrupt? # might have happened in a for-block
+          if token.is_a?(Continue) or token.is_a?(Break)
-        end
+            context.push_interrupt(token.interrupt)
-        idx += 1
+            break
        context.resource_limits.increment_write_score(output)
          end
-      output
+          token_output = render_token(token, context)
          unless token.is_a?(Block) && token.blank?
            @output << token_output
          end
        rescue MemoryError => e
          raise e
        rescue ::StandardError => e
          @output << context.handle_error(e, token)
        end
      end
      @output.join
    end
    private
-    def render_node(context, output, node)
+    def render_token(token, context)
-      BlockBody.render_node(context, output, node)
+      token_output = (token.respond_to?(:render) ? token.render(context) : token)
      token_str = token_output.is_a?(Array) ? token_output.join : token_output.to_s
      context.resource_limits.render_length += token_str.length
      if context.resource_limits.reached?
        raise MemoryError.new("Memory limits exceeded".freeze)
      end
      token_str
    end
-    def create_variable(token, parse_context)
+    def create_variable(token, options)
      token.scan(ContentOfVariable) do |content|
-        markup = content.first
+        markup = token.is_a?(Token) ? token.child(content.first) : content.first
-        return Variable.new(markup, parse_context)
+        return Variable.new(markup, options)
      end
-      BlockBody.raise_missing_variable_terminator(token, parse_context)
+      raise_missing_variable_terminator(token, options)
    end
-    # @deprecated Use {.raise_missing_tag_terminator} instead
+    def raise_missing_tag_terminator(token, options)
-    def raise_missing_tag_terminator(token, parse_context)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
      BlockBody.raise_missing_tag_terminator(token, parse_context)
    end
-    # @deprecated Use {.raise_missing_variable_terminator} instead
+    def raise_missing_variable_terminator(token, options)
-    def raise_missing_variable_terminator(token, parse_context)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
      BlockBody.raise_missing_variable_terminator(token, parse_context)
    end
    def registered_tags
      Template.tags
    end
  end
 end
--- 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,75 +8,45 @@ module Liquid
  #
  class Condition #:nodoc:
    @@operators = {
-      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<' => :<,
+      '<'.freeze  => :<,
-      '>' => :>,
+      '>'.freeze  => :>,
-      '>=' => :>=,
+      '>='.freeze => :>=,
-      '<=' => :<=,
+      '<='.freeze => :<=,
-      'contains' => lambda do |_cond, left, right|
+      'contains'.freeze => lambda { |cond, left, right|
-        if left && right && left.respond_to?(:include?)
+        left && right && left.respond_to?(:include?) ? left.include?(right) : false
          right = right.to_s if left.is_a?(String)
          left.include?(right)
        else
          false
        end
      end,
      }
    class MethodLiteral
      attr_reader :method_name, :to_s
      def initialize(method_name, to_s)
        @method_name = method_name
        @to_s = to_s
      end
    end
    @@method_literals = {
      'blank' => MethodLiteral.new(:blank?, '').freeze,
      'empty' => MethodLiteral.new(:empty?, '').freeze,
    }
    def self.operators
      @@operators
    end
-    def self.parse_expression(markup)
+    attr_reader :attachment
      @@method_literals[markup] || Expression.parse(markup)
    end
    attr_reader :attachment, :child_condition
    attr_accessor :left, :operator, :right
    def initialize(left = nil, operator = nil, right = nil)
      @left = left
      @operator = operator
      @right = right
      @child_relation  = nil
      @child_condition = nil
    end
    def evaluate(context = Context.new)
-      condition = self
+      result = interpret_condition(left, right, operator, context)
      result = nil
      loop do
        result = interpret_condition(condition.left, condition.right, condition.operator, context)
-        case condition.child_relation
+      case @child_relation
      when :or
-          break if result
+        result || @child_condition.evaluate(context)
      when :and
-          break unless result
+        result && @child_condition.evaluate(context)
      else
          break
        end
        condition = condition.child_condition
      end
        result
      end
    end
    def or(condition)
      @child_relation = :or
@@ -99,27 +67,23 @@ module Liquid
    end
    def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
    end
    protected
    attr_reader :child_relation
    private
    def equal_variables(left, right)
-      if left.is_a?(MethodLiteral)
+      if left.is_a?(Symbol)
-        if right.respond_to?(left.method_name)
+        if right.respond_to?(left)
-          return right.send(left.method_name)
+          return right.send(left.to_s)
        else
          return nil
        end
      end
-      if right.is_a?(MethodLiteral)
+      if right.is_a?(Symbol)
-        if left.respond_to?(right.method_name)
+        if left.respond_to?(right)
-          return left.send(right.method_name)
+          return left.send(right.to_s)
        else
          return nil
        end
@@ -132,41 +96,36 @@ module Liquid
      # If the operator is empty this means that the decision statement is just
      # a single variable. We can just poll this variable from the context and
      # return this as the result.
-      return context.evaluate(left) if op.nil?
+      return context.evaluate(left) if op == nil
      left = 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) and right.respond_to?(operation)
        begin
          left.send(operation, right)
        rescue ::ArgumentError => e
-          raise Liquid::ArgumentError, e.message
+          raise Liquid::ArgumentError.new(e.message)
        end
      else
        nil
      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
    def else?
      true
    end
-    def evaluate(_context)
+    def evaluate(context)
      true
    end
  end
 end
--- a/lib/liquid/context.rb
+++ b/lib/liquid/context.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Context keeps the variable stack and resolves variables, as well as keywords
  #
  #   context['variable'] = 'testing'
@@ -14,46 +13,32 @@ module Liquid
  #
  #   context['bob']  #=> nil  class Context
  class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
+    attr_reader :scopes, :registers, :environments, :resource_limits
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
+    attr_accessor :exception_handler
-    # rubocop:disable Metrics/ParameterLists
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {})
+      @environments     = [environments].flatten
      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
      squash_instance_assigns_with_environments
-      self.exception_renderer = Template.default_exception_renderer
+      @this_stack_used = false
      if rethrow_errors
-        self.exception_renderer = ->(_e) { raise }
+        self.exception_handler = ->(e) { true }
      end
-      @interrupts    = []
+      @interrupts = nil
      @filters = []
      @global_filter = nil
      @disabled_tags = {}
    end
    # rubocop:enable Metrics/ParameterLists
-    def warnings
+    def errors
-      @warnings ||= []
+      @errors ||= []
    end
    def strainer
-      @strainer ||= StrainerFactory.create(self, @filters)
+      @strainer ||= Strainer.create(self, @filters)
    end
    # Adds filters to this context.
@@ -66,31 +51,30 @@ module Liquid
      @strainer = nil
    end
    def apply_global_filter(obj)
      global_filter.nil? ? obj : global_filter.call(obj)
    end
    # are there any not handled interrupts?
-    def interrupt?
+    def has_interrupt?
-      !@interrupts.empty?
+      @interrupts && !@interrupts.empty?
    end
    # push an interrupt to the stack. this interrupt is considered not handled.
    def push_interrupt(e)
-      @interrupts.push(e)
+      (@interrupts ||= []).push(e)
    end
    # pop an interrupt from the stack
    def pop_interrupt
-      @interrupts.pop
+      @interrupts.pop if @interrupts
    end
    def handle_error(e, token=nil)
      if e.is_a?(Liquid::Error)
        e.set_line_number_from_token(token)
      end
    def handle_error(e, line_number = nil)
      e = internal_error unless e.is_a?(Liquid::Error)
      e.template_name ||= template_name
      e.line_number   ||= line_number
      errors.push(e)
-      exception_renderer.call(e).to_s
+      raise if exception_handler && exception_handler.call(e)
      Liquid::Error.render(e)
    end
    def invoke(method, *args)
@@ -100,7 +84,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 +106,19 @@ module Liquid
    #   end
    #
    #   context['var]  #=> nil
-    def stack(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
+      pop if @this_stack_used
-    end
+      @this_stack_used = old_stack_used
    # Creates a new context inheriting resource limits, filters, environment etc.,
    # but with an isolated scope.
    def new_isolated_subcontext
      check_overflow
      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
    end
    def clear_instance_assigns
@@ -155,6 +127,10 @@ module Liquid
    # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
    def []=(key, value)
      unless @this_stack_used
        @this_stack_used = true
        push({})
      end
      @scopes[0][key] = value
    end
@@ -170,7 +146,7 @@ module Liquid
      evaluate(Expression.parse(expression))
    end
-    def key?(key)
+    def has_key?(key)
      self[key] != nil
    end
@@ -179,95 +155,47 @@ module Liquid
    end
    # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key, raise_on_not_found: true)
+    def find_variable(key)
      # This was changed from find() to find_index() because this is a very hot
      # path and find_index() is optimized in MRI to reduce object allocation
-      index = @scopes.find_index { |s| s.key?(key) }
+      index = @scopes.find_index { |s| s.has_key?(key) }
      scope = @scopes[index] if index
-      variable = if index
+      variable = nil
-        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
+
-      else
+      if scope.nil?
-        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
+        @environments.each do |e|
          variable = lookup_and_evaluate(e, key)
          unless variable.nil?
            scope = e
            break
          end
        end
      end
      scope     ||= @environments.last || @scopes.last
      variable  ||= lookup_and_evaluate(scope, key)
      variable = variable.to_liquid
      variable.context = self if variable.respond_to?(:context=)
-      variable
+      return variable
    end
-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
+    def lookup_and_evaluate(obj, key)
-      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
+      if (value = obj[key]).is_a?(Proc) && obj.respond_to?(:[]=)
-        raise Liquid::UndefinedVariable, "undefined variable #{key}"
+        obj[key] = (value.arity == 0) ? value.call : value.call(self)
      end
      value = obj[key]
      if value.is_a?(Proc) && obj.respond_to?(:[]=)
        obj[key] = value.arity == 0 ? value.call : value.call(self)
      else
        value
      end
    end
    def with_disabled_tags(tag_names)
      tag_names.each do |name|
        @disabled_tags[name] = @disabled_tags.fetch(name, 0) + 1
      end
      yield
    ensure
      tag_names.each do |name|
        @disabled_tags[name] -= 1
      end
    end
    def tag_disabled?(tag_name)
      @disabled_tags.fetch(tag_name, 0) > 0
    end
    protected
    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
    private
    attr_reader :base_scope_depth
    def try_variable_find_in_environments(key, raise_on_not_found:)
      @environments.each do |environment|
        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
        if !found_variable.nil? || @strict_variables && raise_on_not_found
          return found_variable
        end
      end
      @static_environments.each do |environment|
        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
        if !found_variable.nil? || @strict_variables && raise_on_not_found
          return found_variable
        end
      end
      nil
    end
    def check_overflow
      raise StackLevelError, "Nesting too deep" if overflow?
    end
    def overflow?
      base_scope_depth + @scopes.length > Block::MAX_DEPTH
    end
    def internal_error
      # raise and catch to set backtrace and cause on exception
      raise Liquid::InternalError, 'internal'
    rescue Liquid::InternalError => exc
      exc
    end
      def squash_instance_assigns_with_environments
        @scopes.last.each_key do |k|
          @environments.each do |env|
-          if env.key?(k)
+            if env.has_key?(k)
              scopes.last[k] = lookup_and_evaluate(env, k)
              break
            end
--- a/lib/liquid/document.rb
+++ b/lib/liquid/document.rb
@@ -1,63 +1,23 @@
 # frozen_string_literal: true
 module Liquid
-  class Document
+  class Document < BlockBody
-    def self.parse(tokens, parse_context)
+    def self.parse(tokens, options)
-      doc = new(parse_context)
+      doc = new
-      doc.parse(tokens, parse_context)
+      doc.parse(tokens, options)
      doc
    end
-    attr_reader :parse_context, :body
+    def parse(tokens, options)
-
+      super do |end_tag_name, end_tag_params|
-    def initialize(parse_context)
+        unknown_tag(end_tag_name, options) if end_tag_name
-      @parse_context = parse_context
+      end
      @body = new_body
    end
-    def nodelist
+    def unknown_tag(tag, options)
      @body.nodelist
    end
    def parse(tokenizer, parse_context)
      while parse_body(tokenizer)
      end
    rescue SyntaxError => e
      e.line_number ||= parse_context.line_number
      raise
    end
    def unknown_tag(tag, _markup, _tokenizer)
      case tag
-      when 'else', 'end'
+      when 'else'.freeze, 'end'.freeze
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag", tag: tag)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_outer_tag".freeze, :tag => tag))
      else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
      end
    end
    def render_to_output_buffer(context, output)
      @body.render_to_output_buffer(context, output)
    end
    def render(context)
      @body.render(context)
    end
    private
    def new_body
      parse_context.new_block_body
    end
    def parse_body(tokenizer)
      @body.parse(tokenizer, parse_context) do |unknown_tag_name, unknown_tag_markup|
        if unknown_tag_name
          unknown_tag(unknown_tag_name, unknown_tag_markup, tokenizer)
          true
        else
          false
        end
      end
    end
  end
--- a/lib/liquid/drop.rb
+++ b/lib/liquid/drop.rb
@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 require 'set'
 module Liquid
  # A drop in liquid is a class which allows you to export DOM like things to liquid.
  # Methods of drops are callable.
  # The main use for liquid drops is to implement lazy loaded objects.
@@ -20,27 +19,28 @@ module Liquid
  #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
  #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
  #
-  # Your drop can either implement the methods sans any parameters
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
-  # or implement the liquid_method_missing(name) method which is a catch all.
+  # catch all.
  class Drop
    attr_writer :context
    EMPTY_STRING = ''.freeze
    # Catch all for the method
-    def liquid_method_missing(method)
+    def before_method(method)
-      return nil unless @context&.strict_variables
+      nil
      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
    end
    # called by liquid to invoke a drop
    def invoke_drop(method_or_key)
-      if self.class.invokable?(method_or_key)
+      if method_or_key && method_or_key != EMPTY_STRING && self.class.invokable?(method_or_key)
        send(method_or_key)
      else
-        liquid_method_missing(method_or_key)
+        before_method(method_or_key)
      end
    end
-    def key?(_name)
+    def has_key?(name)
      true
    end
@@ -56,25 +56,26 @@ module Liquid
      self.class.name
    end
-    alias_method :[], :invoke_drop
+    alias :[] :invoke_drop
    private
    # Check for method existence without invoking respond_to?, which creates symbols
    def self.invokable?(method_name)
-      invokable_methods.include?(method_name.to_s)
+      self.invokable_methods.include?(method_name.to_s)
    end
    def self.invokable_methods
-      @invokable_methods ||= begin
+      unless @invokable_methods
        blacklist = Liquid::Drop.public_instance_methods + [:each]
        if include?(Enumerable)
          blacklist += Enumerable.public_instance_methods
-          blacklist -= [:sort, :count, :first, :min, :max]
+          blacklist -= [:sort, :count, :first, :min, :max, :include?]
        end
        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
-        Set.new(whitelist.map(&:to_s))
+        @invokable_methods = Set.new(whitelist.map(&:to_s))
-      end
+      end
      @invokable_methods
    end
  end
 end
--- a/lib/liquid/errors.rb
+++ b/lib/liquid/errors.rb
@@ -1,13 +1,10 @@
 # frozen_string_literal: true
 module Liquid
  class Error < ::StandardError
    attr_accessor :line_number
    attr_accessor :template_name
    attr_accessor :markup_context
    def to_s(with_prefix=true)
-      str = +""
+      str = ""
      str << message_prefix if with_prefix
      str << super()
@@ -19,20 +16,32 @@ module Liquid
      str
    end
    def set_line_number_from_token(token)
      return unless token.respond_to?(:line_number)
      return if self.line_number
      self.line_number = token.line_number
    end
    def self.render(e)
      if e.is_a?(Liquid::Error)
        e.to_s
      else
        "Liquid error: #{e.to_s}"
      end
    end
    private
    def message_prefix
-      str = +""
+      str = ""
-      str << if is_a?(SyntaxError)
+      if is_a?(SyntaxError)
-        "Liquid syntax error"
+        str << "Liquid syntax error"
      else
-        "Liquid error"
+        str << "Liquid error"
      end
      if line_number
-        str << " ("
+        str << " (line #{line_number})"
        str << template_name << " " if template_name
        str << "line " << line_number.to_s << ")"
      end
      str << ": "
@@ -40,19 +49,12 @@ module Liquid
    end
  end
-  ArgumentError       = Class.new(Error)
+  class ArgumentError < Error; end
-  ContextError        = Class.new(Error)
+  class ContextError < Error; end
-  FileSystemError     = Class.new(Error)
+  class FileSystemError < Error; end
-  StandardError       = Class.new(Error)
+  class StandardError < Error; end
-  SyntaxError         = Class.new(Error)
+  class SyntaxError < Error; end
-  StackLevelError     = Class.new(Error)
+  class StackLevelError < Error; end
-  MemoryError         = Class.new(Error)
+  class TaintedError < Error; end
-  ZeroDivisionError   = Class.new(Error)
+  class MemoryError < Error; end
  FloatDomainError    = Class.new(Error)
  UndefinedVariable   = Class.new(Error)
  UndefinedDropMethod = Class.new(Error)
  UndefinedFilter     = Class.new(Error)
  MethodOverrideError = Class.new(Error)
  DisabledError       = Class.new(Error)
  InternalError       = Class.new(Error)
 end
--- a/lib/liquid/expression.rb
+++ b/lib/liquid/expression.rb
@@ -1,38 +1,33 @@
 # frozen_string_literal: true
 module Liquid
  class Expression
    LITERALS = {
-      nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
+      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true' => true,
+      'true'.freeze  => true,
-      'false' => false,
+      'false'.freeze => false,
-      'blank' => '',
+      'blank'.freeze => :blank?,
-      'empty' => ''
+      'empty'.freeze => :empty?
-    }.freeze
+    }
    SINGLE_QUOTED_STRING = /\A'(.*)'\z/m
    DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m
    INTEGERS_REGEX       = /\A(-?\d+)\z/
    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/
    RANGES_REGEX         = /\A\((\S+)\.\.(\S+)\)\z/
    def self.parse(markup)
      if LITERALS.key?(markup)
        LITERALS[markup]
      else
        case markup
-        when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
+        when /\A'(.*)'\z/m # Single quoted strings
-          Regexp.last_match(1)
+          $1
-        when INTEGERS_REGEX
+        when /\A"(.*)"\z/m # Double quoted strings
-          Regexp.last_match(1).to_i
+          $1
-        when RANGES_REGEX
+        when /\A(-?\d+)\z/ # Integer and floats
-          RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
+          $1.to_i
-        when FLOATS_REGEX
+        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
-          Regexp.last_match(1).to_f
+          RangeLookup.parse($1, $2)
        when /\A(-?\d[\d\.]+)\z/ # Floats
          $1.to_f
        else
          VariableLookup.parse(markup)
        end
      end
    end
  end
 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
@@ -33,12 +25,6 @@ class Numeric # :nodoc:
  end
 end
 class Range # :nodoc:
  def to_liquid
    self
  end
 end
 class Time  # :nodoc:
  def to_liquid
    self
--- 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.
  #
@@ -16,7 +14,7 @@ module Liquid
  # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
  class BlankFileSystem
    # Called by Liquid to retrieve a template file
-    def read_template_file(_template_path)
+    def read_template_file(template_path)
      raise FileSystemError, "This liquid context does not allow includes."
    end
  end
@@ -46,28 +44,28 @@ module Liquid
  class LocalFileSystem
    attr_accessor :root
-    def initialize(root, pattern = "_%s.liquid")
+    def initialize(root, pattern = "_%s.liquid".freeze)
      @root = root
      @pattern = pattern
    end
    def read_template_file(template_path)
      full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
      File.read(full_path)
    end
    def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless %r{\A[^./][a-zA-Z0-9_/]+\z}.match?(template_path)
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
-      full_path = if template_path.include?('/')
+      full_path = if template_path.include?('/'.freeze)
        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
      else
        File.join(root, @pattern % template_path)
      end
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path).start_with?(File.expand_path(root))
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /\A#{File.expand_path(root)}/
      full_path
    end
--- a/lib/liquid/forloop_drop.rb
+++ b/lib/liquid/forloop_drop.rb
@@ -1,44 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class ForloopDrop < Drop
    def initialize(name, length, parentloop)
      @name       = name
      @length     = length
      @parentloop = parentloop
      @index      = 0
    end
    attr_reader :name, :length, :parentloop
    def index
      @index + 1
    end
    def index0
      @index
    end
    def rindex
      @length - @index
    end
    def rindex0
      @length - @index - 1
    end
    def first
      @index == 0
    end
    def last
      @index == @length - 1
    end
    protected
    def increment!
      @index += 1
    end
  end
 end
--- a/lib/liquid/i18n.rb
+++ b/lib/liquid/i18n.rb
@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 require 'yaml'
 module Liquid
  class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
+    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
-    TranslationError = Class.new(StandardError)
+    class TranslationError < StandardError
    end
    attr_reader :path
@@ -24,17 +23,16 @@ module Liquid
    end
    private
    def interpolate(name, vars)
-      name.gsub(/%\{(\w+)\}/) do
+      name.gsub(/%\{(\w+)\}/) {
        # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        (vars[Regexp.last_match(1).to_sym]).to_s
+        "#{vars[$1.to_sym]}"
-      end
+      }
    end
    def deep_fetch_translation(name)
-      name.split('.').reduce(locale) do |level, cur|
+      name.split('.'.freeze).reduce(locale) do |level, cur|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
      end
    end
  end
--- a/lib/liquid/interrupts.rb
+++ b/lib/liquid/interrupts.rb
@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 module Liquid
  # An interrupt is any command that breaks processing of a block (ex: a for loop).
  class Interrupt
    attr_reader :message
    def initialize(message=nil)
-      @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,
+      '|'.freeze => :pipe,
-      '.' => :dot,
+      '.'.freeze => :dot,
-      ':' => :colon,
+      ':'.freeze => :colon,
-      ',' => :comma,
+      ','.freeze => :comma,
-      '[' => :open_square,
+      '['.freeze => :open_square,
-      ']' => :close_square,
+      ']'.freeze => :close_square,
-      '(' => :open_round,
+      '('.freeze => :open_round,
-      ')' => :close_round,
+      ')'.freeze => :close_round,
-      '?' => :question,
+      '?'.freeze => :question,
-      '-' => :dash,
+      '-'.freeze => :dash
-    }.freeze
+    }
    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
    SINGLE_STRING_LITERAL = /'[^\']*'/
    DOUBLE_STRING_LITERAL = /"[^\"]*"/
    NUMBER_LITERAL = /-?\d+(\.\d+)?/
    DOTDOT = /\.\./
-    COMPARISON_OPERATOR   = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
    WHITESPACE_OR_NOTHING = /\s*/
    def initialize(input)
-      @ss = StringScanner.new(input)
+      @ss = StringScanner.new(input.rstrip)
    end
    def tokenize
      @output = []
-      until @ss.eos?
+      while !@ss.eos?
-        @ss.skip(WHITESPACE_OR_NOTHING)
+        @ss.skip(/\s*/)
-        break if @ss.eos?
+        tok = case
-        tok      = if (t = @ss.scan(COMPARISON_OPERATOR))
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
-          [:comparison, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
-        elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
-          [:string, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
-        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL))
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
-          [:string, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
        elsif (t = @ss.scan(NUMBER_LITERAL))
          [:number, t]
        elsif (t = @ss.scan(IDENTIFIER))
          [:id, t]
        elsif (t = @ss.scan(DOTDOT))
          [:dotdot, t]
        else
          c = @ss.getch
-          if (s = SPECIALS[c])
+          if s = SPECIALS[c]
            [s,c]
          else
            raise SyntaxError, "Unexpected character #{c}"
--- a/lib/liquid/locales/en.yml
+++ b/lib/liquid/locales/en.yml
@@ -1,7 +1,6 @@
 ---
  errors:
    syntax:
      tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: %{tag}"
      assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
      capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
      case: "Syntax Error in 'case' - Valid syntax: case [condition]"
@@ -14,7 +13,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 +21,3 @@
      tag_never_closed: "'%{block_name}' tag was never closed"
      meta_syntax_error: "Liquid syntax error: #{e.message}"
      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
      render: "Syntax error in tag 'render' - Template name must be a quoted string"
    argument:
      include: "Argument error in tag 'include' - Illegal template name"
    disabled:
      tag: "usage is not allowed in this context"
--- a/lib/liquid/module_ex.rb
+++ b/lib/liquid/module_ex.rb
@@ -0,0 +1,64 @@
 # Copyright 2007 by Domizio Demichelis
 # This library is free software. It may be used, redistributed and/or modified
 # under the same terms as Ruby itself
 #
 # This extension is used in order to expose the object of the implementing class
 # to liquid as it were a Drop. It also limits the liquid-callable methods of the instance
 # to the allowed method passed with the liquid_methods call
 # Example:
 #
 #   class SomeClass
 #     liquid_methods :an_allowed_method
 #
 #     def an_allowed_method
 #       'this comes from an allowed method'
 #     end
 #
 #     def unallowed_method
 #       'this will never be an output'
 #     end
 #   end
 #
 # if you want to extend the drop to other methods you can defines more methods
 # in the class <YourClass>::LiquidDropClass
 #
 #   class SomeClass::LiquidDropClass
 #     def another_allowed_method
 #       'and this from another allowed method'
 #     end
 #   end
 #
 #
 # usage:
 #   @something = SomeClass.new
 #
 # template:
 #   {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
 #
 # output:
 #   'this comes from an allowed method and this from another allowed method'
 #
 # You can also chain associations, by adding the liquid_method call in the
 # association models.
 #
 class Module
  def liquid_methods(*allowed_methods)
    drop_class = eval "class #{self.to_s}::LiquidDropClass < Liquid::Drop; self; end"
    define_method :to_liquid do
      drop_class.new(self)
    end
    drop_class.class_eval do
      def initialize(object)
        @object = object
      end
      allowed_methods.each do |sym|
        define_method sym do
          @object.send sym
        end
      end
    end
  end
 end
--- a/lib/liquid/parse_context.rb
+++ b/lib/liquid/parse_context.rb
@@ -1,46 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class ParseContext
    attr_accessor :locale, :line_number, :trim_whitespace, :depth
    attr_reader :partial, :warnings, :error_mode
    def initialize(options = {})
      @template_options = options ? options.dup : {}
      @locale   = @template_options[:locale] ||= I18n.new
      @warnings = []
      self.depth   = 0
      self.partial = false
    end
    def [](option_key)
      @options[option_key]
    end
    def new_block_body
      Liquid::BlockBody.new
    end
    def partial=(value)
      @partial = value
      @options = value ? partial_options : @template_options
      @error_mode = @options[:error_mode] || Template.error_mode
    end
    def partial_options
      @partial_options ||= begin
        dont_pass = @template_options[:include_options_blacklist]
        if dont_pass == true
          { locale: locale }
        elsif dont_pass.is_a?(Array)
          @template_options.reject { |k, _v| dont_pass.include?(k) }
        else
          @template_options
        end
      end
    end
  end
 end
--- a/lib/liquid/parse_tree_visitor.rb
+++ b/lib/liquid/parse_tree_visitor.rb
@@ -1,42 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class ParseTreeVisitor
    def self.for(node, callbacks = Hash.new(proc {}))
      if defined?(node.class::ParseTreeVisitor)
        node.class::ParseTreeVisitor
      else
        self
      end.new(node, callbacks)
    end
    def initialize(node, callbacks)
      @node      = node
      @callbacks = callbacks
    end
    def add_callback_for(*classes, &block)
      callback = block
      callback = ->(node, _) { yield node } if block.arity.abs == 1
      callback = ->(_, _) { yield } if block.arity.zero?
      classes.each { |klass| @callbacks[klass] = callback }
      self
    end
    def visit(context = nil)
      children.map do |node|
        item, new_context = @callbacks[node.class].call(node, context)
        [
          item,
          ParseTreeVisitor.for(node, @callbacks).visit(new_context || context),
        ]
      end
    end
    protected
    def children
      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : []
    end
  end
 end
--- a/lib/liquid/parser.rb
+++ b/lib/liquid/parser.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  class Parser
    def initialize(input)
@@ -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
@@ -80,7 +75,7 @@ module Liquid
    def variable_signature
      str = consume(:id)
-      while look(:open_square)
+      if look(:open_square)
        str << consume
        str << expression
        str << consume(:close_square)
--- a/lib/liquid/parser_switching.rb
+++ b/lib/liquid/parser_switching.rb
@@ -1,27 +1,25 @@
 # frozen_string_literal: true
 module Liquid
  module ParserSwitching
    def parse_with_selected_parser(markup)
-      case parse_context.error_mode
+      case @options[:error_mode] || Template.error_mode
      when :strict then strict_parse_with_error_context(markup)
      when :lax    then lax_parse(markup)
      when :warn
        begin
-          strict_parse_with_error_context(markup)
+          return strict_parse_with_error_context(markup)
        rescue SyntaxError => e
-          parse_context.warnings << e
+          e.set_line_number_from_token(markup)
-          lax_parse(markup)
+          @warnings ||= []
          @warnings << e
          return lax_parse(markup)
        end
      end
    end
    private
    def strict_parse_with_error_context(markup)
      strict_parse(markup)
    rescue SyntaxError => e
      e.line_number    = line_number
      e.markup_context = markup_context(markup)
      raise e
    end
--- 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,8 +1,7 @@
 # frozen_string_literal: true
 require 'liquid/profiler/hooks'
 module Liquid
  # Profiler enables support for profiling template rendering to help track down performance issues.
  #
  # To enable profiling, first require 'liquid/profiler'.
@@ -21,7 +20,7 @@ module Liquid
  # inside of <tt>{% include %}</tt> tags.
  #
  #   profile.each do |node|
-  #     # Access to the node itself
+  #     # Access to the token itself
  #     node.code
  #
  #     # Which template and line number of this node.
@@ -46,17 +45,19 @@ 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)
+      def initialize(token, partial)
-        @code        = node.respond_to?(:raw) ? node.raw : node
+        @code        = token.respond_to?(:raw) ? token.raw : token
        @partial     = partial
-        @line_number = node.respond_to?(:line_number) ? node.line_number : nil
+        @line_number = token.respond_to?(:line_number) ? token.line_number : nil
        @children    = []
      end
-      def self.start(node, partial)
+      def self.start(token, partial)
-        new(node, partial).tap(&:start)
+        new(token, partial).tap do |t|
          t.start
        end
      end
      def start
@@ -65,17 +66,6 @@ module Liquid
      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
      def render_time
@@ -83,11 +73,11 @@ module Liquid
      end
    end
-    def self.profile_node_render(node)
+    def self.profile_token_render(token)
-      if Profiler.current_profile && node.respond_to?(:render)
+      if Profiler.current_profile && token.respond_to?(:render)
-        Profiler.current_profile.start_node(node)
+        Profiler.current_profile.start_token(token)
        output = yield
-        Profiler.current_profile.end_node(node)
+        Profiler.current_profile.end_token(token)
        output
      else
        yield
@@ -109,8 +99,8 @@ module Liquid
      Thread.current[:liquid_profiler]
    end
-    def initialize(partial_name = "<root>")
+    def initialize
-      @partial_stack = [partial_name]
+      @partial_stack = ["<root>"]
      @root_timing = Timing.new("", current_partial)
      @timing_stack = [@root_timing]
@@ -145,11 +135,11 @@ module Liquid
      @root_timing.children.length
    end
-    def start_node(node)
+    def start_token(token)
-      @timing_stack.push(Timing.start(node, current_partial))
+      @timing_stack.push(Timing.start(token, current_partial))
    end
-    def end_node(_node)
+    def end_token(token)
      timing = @timing_stack.pop
      timing.finish
@@ -167,5 +157,6 @@ module Liquid
    def pop_partial
      @partial_stack.pop
    end
  end
 end
--- a/lib/liquid/profiler/hooks.rb
+++ b/lib/liquid/profiler/hooks.rb
@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 module Liquid
-  module BlockBodyProfilingHook
+  class BlockBody
-    def render_node(context, output, node)
+    def render_token_with_profiling(token, context)
-      Profiler.profile_node_render(node) do
+      Profiler.profile_token_render(token) do
-        super
+        render_token_without_profiling(token, context)
      end
    end
  end
  BlockBody.prepend(BlockBodyProfilingHook)
-  module IncludeProfilingHook
+    alias_method :render_token_without_profiling, :render_token
-    def render_to_output_buffer(context, output)
+    alias_method :render_token, :render_token_with_profiling
-      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
+  end
-        super
+
  class Include < Tag
    def render_with_profiling(context)
      Profiler.profile_children(context.evaluate(@template_name).to_s) do
        render_without_profiling(context)
      end
    end
    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,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  class RangeLookup
    def self.parse(start_markup, end_markup)
@@ -18,22 +16,7 @@ module Liquid
    end
    def evaluate(context)
-      start_int = to_integer(context.evaluate(@start_obj))
+      context.evaluate(@start_obj).to_i..context.evaluate(@end_obj).to_i
      end_int   = to_integer(context.evaluate(@end_obj))
      start_int..end_int
    end
    private
    def to_integer(input)
      case input
      when Integer
        input
      when NilClass, String
        input.to_i
      else
        Utils.to_integer(input)
      end
    end
  end
 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,9 +1,7 @@
 # frozen_string_literal: true
 module Liquid
  class ResourceLimits
-    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
+    attr_accessor :render_length, :render_score, :assign_score,
-    attr_reader :render_score, :assign_score
+                  :render_length_limit, :render_score_limit, :assign_score_limit
    def initialize(limits)
      @render_length_limit = limits[:render_length_limit]
@@ -12,51 +10,14 @@ module Liquid
      reset
    end
    def increment_render_score(amount)
      @render_score += amount
      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
    end
    def increment_assign_score(amount)
      @assign_score += amount
      raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
    end
    # update either render_length or assign_score based on whether or not the writes are captured
    def increment_write_score(output)
      if (last_captured = @last_capture_length)
        captured = output.bytesize
        increment = captured - last_captured
        @last_capture_length = captured
        increment_assign_score(increment)
      elsif @render_length_limit && output.bytesize > @render_length_limit
        raise_limits_reached
      end
    end
    def raise_limits_reached
      @reached_limit = true
      raise MemoryError, "Memory limits exceeded"
    end
    def reached?
-      @reached_limit
+      (@render_length_limit && @render_length > @render_length_limit) ||
      (@render_score_limit  && @render_score  > @render_score_limit ) ||
      (@assign_score_limit  && @assign_score  > @assign_score_limit )
    end
    def reset
-      @reached_limit = false
+      @render_length = @render_score = @assign_score = 0
      @last_capture_length = nil
      @render_score = @assign_score = 0
    end
    def with_capture
      old_capture_length = @last_capture_length
      begin
        @last_capture_length = 0
        yield
      ensure
        @last_capture_length = old_capture_length
      end
    end
  end
 end
--- a/lib/liquid/standardfilters.rb
+++ b/lib/liquid/standardfilters.rb
@@ -1,24 +1,17 @@
 # frozen_string_literal: true
 require 'cgi'
 require 'bigdecimal'
 module Liquid
  module StandardFilters
    HTML_ESCAPE = {
-      '&' => '&amp;',
+      '&'.freeze => '&amp;'.freeze,
-      '>' => '&gt;',
+      '>'.freeze => '&gt;'.freeze,
-      '<' => '&lt;',
+      '<'.freeze => '&lt;'.freeze,
-      '"' => '&quot;',
+      '"'.freeze => '&quot;'.freeze,
-      "'" => '&#39;',
+      "'".freeze => '&#39;'.freeze
-    }.freeze
+    }
    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
    STRIP_HTML_BLOCKS       = Regexp.union(
      %r{<script.*?</script>}m,
      /<!--.*?-->/m,
      %r{<style.*?</style>}m
    )
    STRIP_HTML_TAGS = /<.*?>/m
    # Return the size of an array or of an string
    def size(input)
@@ -41,7 +34,7 @@ module Liquid
    end
    def escape(input)
-      CGI.escapeHTML(input.to_s) unless input.nil?
+      CGI.escapeHTML(input).untaint rescue input
    end
    alias_method :h, :escape
@@ -50,21 +43,12 @@ module Liquid
    end
    def url_encode(input)
-      CGI.escape(input.to_s) unless input.nil?
+      CGI.escape(input) rescue input
    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
    end
    def slice(input, offset, length=nil)
-      offset = Utils.to_integer(offset)
+      offset = Integer(offset)
-      length = length ? Utils.to_integer(length) : 1
+      length = length ? Integer(length) : 1
      if input.is_a?(Array)
        input.slice(offset, length) || []
@@ -74,28 +58,19 @@ 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?
+      if input.nil? then return end
-      input_str = input.to_s
+      l = length.to_i - truncate_string.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.length > length.to_i ? input[0...l] + truncate_string : input
      input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
    end
-    def truncatewords(input, words = 15, truncate_string = "...")
+    def truncatewords(input, words = 15, truncate_string = "...".freeze)
-      return if input.nil?
+      if input.nil? then return end
      wordlist = input.to_s.split
-      words    = Utils.to_integer(words)
+      l = words.to_i - 1
      l = words - 1
      l = 0 if l < 0
-
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
      wordlist.length > l ? wordlist[0..l].join(" ").concat(truncate_string.to_s) : input
    end
    # Split input string into an array of substrings separated by given pattern.
@@ -104,7 +79,7 @@ module Liquid
    #   <div class="summary">{{ post | split '//' | first }}</div>
    #
    def split(input, pattern)
-      input.to_s.split(pattern.to_s)
+      input.to_s.split(pattern)
    end
    def strip(input)
@@ -120,160 +95,81 @@ module Liquid
    end
    def strip_html(input)
-      empty  = ''
+      empty = ''.freeze
-      result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
+      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
      result.gsub!(STRIP_HTML_TAGS, empty)
      result
    end
    # Remove all newlines from the string
    def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, '')
+      input.to_s.gsub(/\r?\n/, ''.freeze)
    end
    # Join elements of the array with certain character between them
-    def join(input, glue = ' ')
+    def join(input, glue = ' '.freeze)
-      InputIterator.new(input, context).join(glue)
+      InputIterator.new(input).join(glue)
    end
    # Sort elements of the array
    # provide optional property with which to sort an array of hashes or drops
    def sort(input, property = nil)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)
      return [] if ary.empty?
      if property.nil?
-        ary.sort do |a, b|
+        ary.sort
-          nil_safe_compare(a, b)
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        end
+        ary.sort {|a,b| a[property] <=> b[property] }
-      elsif ary.all? { |el| el.respond_to?(:[]) }
+      elsif ary.first.respond_to?(property)
-        begin
+        ary.sort {|a,b| a.send(property) <=> b.send(property) }
          ary.sort { |a, b| nil_safe_compare(a[property], b[property]) }
        rescue TypeError
          raise_property_error(property)
        end
      end
    end
    # Sort elements of an array ignoring case if strings
    # provide optional property with which to sort an array of hashes or drops
    def sort_natural(input, property = nil)
      ary = InputIterator.new(input, context)
      return [] if ary.empty?
      if property.nil?
        ary.sort do |a, b|
          nil_safe_casecmp(a, b)
        end
      elsif ary.all? { |el| el.respond_to?(:[]) }
        begin
          ary.sort { |a, b| nil_safe_casecmp(a[property], b[property]) }
        rescue TypeError
          raise_property_error(property)
        end
      end
    end
    # Filter the elements of an array to those with a certain property value.
    # By default the target is any truthy value.
    def where(input, property, target_value = nil)
      ary = InputIterator.new(input, context)
      if ary.empty?
        []
      elsif ary.first.respond_to?(:[]) && target_value.nil?
        begin
          ary.select { |item| item[property] }
        rescue TypeError
          raise_property_error(property)
        end
      elsif ary.first.respond_to?(:[])
        begin
          ary.select { |item| item[property] == target_value }
        rescue TypeError
          raise_property_error(property)
        end
      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
+        input.uniq
-      elsif ary.empty? # The next two cases assume a non-empty array.
+      elsif input.first.respond_to?(:[])
-        []
+        input.uniq{ |a| a[property] }
      elsif ary.first.respond_to?(:[])
        begin
          ary.uniq { |a| a[property] }
        rescue TypeError
          raise_property_error(property)
        end
      end
    end
    # Reverse the elements of an array
    def reverse(input)
-      ary = InputIterator.new(input, context)
+      ary = InputIterator.new(input)
      ary.reverse
    end
    # map/collect on a given property
    def map(input, property)
-      InputIterator.new(input, context).map do |e|
+      InputIterator.new(input).map do |e|
        e = e.call if e.is_a?(Proc)
-        if property == "to_liquid"
+        if property == "to_liquid".freeze
          e
        elsif e.respond_to?(:[])
-          r = e[property]
+          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)
      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
      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)
+      input.to_s.gsub(string, 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)
+      input.to_s.sub(string, replacement.to_s)
    end
    # remove a substring
    def remove(input, string)
-      input.to_s.gsub(string.to_s, '')
+      input.to_s.gsub(string, ''.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, ''.freeze)
    end
    # add one string to another
@@ -282,10 +178,7 @@ module Liquid
    end
    def concat(input, array)
-      unless array.respond_to?(:to_ary)
+      InputIterator.new(input).concat(array)
        raise ArgumentError, "concat filter requires an array argument"
      end
      InputIterator.new(input, context).concat(array)
    end
    # prepend a string to another
@@ -295,7 +188,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 +225,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 = to_date(input)
      date.strftime(format.to_s)
    end
@@ -355,12 +248,6 @@ module Liquid
      array.last if array.respond_to?(:last)
    end
    # absolute value
    def abs(input)
      result = Utils.to_number(input).abs
      result.is_a?(BigDecimal) ? result.to_f : result
    end
    # addition
    def plus(input, operand)
      apply_operation(input, operand, :+)
@@ -379,103 +266,75 @@ module Liquid
    # division
    def divided_by(input, operand)
      apply_operation(input, operand, :/)
    rescue ::ZeroDivisionError => e
      raise Liquid::ZeroDivisionError, e.message
    end
    def modulo(input, operand)
      apply_operation(input, operand, :%)
    rescue ::ZeroDivisionError => e
      raise Liquid::ZeroDivisionError, e.message
    end
    def round(input, n = 0)
-      result = Utils.to_number(input).round(Utils.to_number(n))
+      result = to_number(input).round(to_number(n))
      result = result.to_f if result.is_a?(BigDecimal)
      result = result.to_i if n == 0
      result
    rescue ::FloatDomainError => e
      raise Liquid::FloatDomainError, e.message
    end
    def ceil(input)
-      Utils.to_number(input).ceil.to_i
+      to_number(input).ceil.to_i
    rescue ::FloatDomainError => e
      raise Liquid::FloatDomainError, e.message
    end
    def floor(input)
-      Utils.to_number(input).floor.to_i
+      to_number(input).floor.to_i
    rescue ::FloatDomainError => e
      raise Liquid::FloatDomainError, e.message
    end
-    def at_least(input, n)
+    def default(input, default_value = "".freeze)
-      min_value = Utils.to_number(n)
+      is_blank = input.respond_to?(:empty?) ? input.empty? : !input
-
+      is_blank ? default_value : input
      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
    end
    private
-    attr_reader :context
+    def to_number(obj)
      case obj
      when Float
        BigDecimal.new(obj.to_s)
      when Numeric
        obj
      when String
        (obj.strip =~ /\A\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
      else
        0
      end
    end
-    def raise_property_error(property)
+    def to_date(obj)
-      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
+      return obj if obj.respond_to?(:strftime)
      obj = obj.downcase if obj.is_a?(String)
      case obj
      when 'now'.freeze, 'today'.freeze
        Time.now
      when /\A\d+\z/, Integer
        Time.at(obj.to_i)
      when String
        Time.parse(obj)
      else
        nil
      end
    rescue ArgumentError
      nil
    end
    def apply_operation(input, operand, operation)
-      result = Utils.to_number(input).send(operation, Utils.to_number(operand))
+      result = to_number(input).send(operation, to_number(operand))
      result.is_a?(BigDecimal) ? result.to_f : result
    end
    def nil_safe_compare(a, b)
      if !a.nil? && !b.nil?
        a <=> b
      else
        a.nil? ? 1 : -1
      end
    end
    def nil_safe_casecmp(a, b)
      if !a.nil? && !b.nil?
        a.to_s.casecmp(b.to_s)
      else
        a.nil? ? 1 : -1
      end
    end
    class InputIterator
      include Enumerable
-      def initialize(input, context)
+      def initialize(input)
        @context = context
        @input = if input.is_a?(Array)
          input.flatten
        elsif input.is_a?(Hash)
@@ -488,33 +347,19 @@ module Liquid
      end
      def join(glue)
-        to_a.join(glue.to_s)
+        to_a.join(glue)
      end
      def concat(args)
-        to_a.concat(args)
+        to_a.concat args
      end
      def reverse
        reverse_each.to_a
      end
      def uniq(&block)
        to_a.uniq(&block)
      end
      def compact
        to_a.compact
      end
      def empty?
        @input.each { return false }
        true
      end
      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,59 @@
 require 'set'
 module Liquid
  # Strainer is the parent class for the filters system.
  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
  #
  # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
  # Context#add_filters or Template.register_filter
  class Strainer #:nodoc:
    @@global_strainer = Class.new(Strainer) do
      @filter_methods = Set.new
    end
    @@strainer_class_cache = Hash.new do |hash, filters|
      hash[filters] = Class.new(@@global_strainer) do
        @filter_methods = @@global_strainer.filter_methods.dup
        filters.each { |f| add_filter(f) }
      end
    end
    def initialize(context)
      @context = context
    end
    def self.filter_methods
      @filter_methods
    end
    def self.add_filter(filter)
      raise ArgumentError, "Expected module but got: #{f.class}" unless filter.is_a?(Module)
      unless self.class.include?(filter)
        self.send(:include, filter)
        @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
      end
    end
    def self.global_filter(filter)
      @@global_strainer.add_filter(filter)
    end
    def self.invokable?(method)
      @filter_methods.include?(method.to_s)
    end
    def self.create(context, filters = [])
      @@strainer_class_cache[filters].new(context)
    end
    def invoke(method, *args)
      if self.class.invokable?(method)
        send(method, *args)
      else
        args.first
      end
    rescue ::ArgumentError => e
      raise Liquid::ArgumentError.new(e.message)
    end
  end
 end
--- 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,64 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class TablerowloopDrop < Drop
    def initialize(length, cols)
      @length = length
      @row    = 1
      @col    = 1
      @cols   = cols
      @index  = 0
    end
    attr_reader :length, :col, :row
    def index
      @index + 1
    end
    def index0
      @index
    end
    def col0
      @col - 1
    end
    def rindex
      @length - @index
    end
    def rindex0
      @length - @index - 1
    end
    def first
      @index == 0
    end
    def last
      @index == @length - 1
    end
    def col_first
      @col == 1
    end
    def col_last
      @col == @cols
    end
    protected
    def increment!
      @index += 1
      if @col == @cols
        @col = 1
        @row += 1
      else
        @col += 1
      end
    end
  end
 end
--- a/lib/liquid/tag.rb
+++ b/lib/liquid/tag.rb
@@ -1,35 +1,26 @@
 # frozen_string_literal: true
 module Liquid
  class Tag
-    attr_reader :nodelist, :tag_name, :line_number, :parse_context
+    attr_accessor :options, :line_number
-    alias_method :options, :parse_context
+    attr_reader :nodelist, :warnings
    include ParserSwitching
    class << self
-      def parse(tag_name, markup, tokenizer, parse_context)
+      def parse(tag_name, markup, tokens, options)
-        tag = new(tag_name, markup, parse_context)
+        tag = new(tag_name, markup, options)
-        tag.parse(tokenizer)
+        tag.parse(tokens)
        tag
      end
      def disable_tags(*tag_names)
        @disabled_tags ||= []
        @disabled_tags.concat(tag_names)
        prepend(Disabler)
      end
      private :new
    end
-    def initialize(tag_name, markup, parse_context)
+    def initialize(tag_name, markup, options)
      @tag_name   = tag_name
      @markup     = markup
-      @parse_context = parse_context
+      @options    = options
      @line_number   = parse_context.line_number
    end
-    def parse(_tokens)
+    def parse(tokens)
    end
    def raw
@@ -40,16 +31,8 @@ module Liquid
      self.class.name.downcase
    end
-    def render(_context)
+    def render(context)
-      ''
+      ''.freeze
    end
    # For backwards compatibility with custom tags. In a future release, the semantics
    # of the `render_to_output_buffer` method will become the default and the `render`
    # method will be removed.
    def render_to_output_buffer(context, output)
      output << render(context)
      output
    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,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Assign sets a variable in your template.
  #
  #   {% assign foo = 'monkey' %}
@@ -12,50 +11,31 @@ 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)
+        @to = $1
-        @from = Variable.new(Regexp.last_match(2), options)
+        @from = Variable.new($2,options)
        @from.line_number = line_number
      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.increment_assign_score(assign_score_of(val))
+
-      output
+      inc = val.instance_of?(String) || val.instance_of?(Array) || val.instance_of?(Hash) ? val.length : 1
      context.resource_limits.assign_score += inc
      ''.freeze
    end
    def blank?
      true
    end
    private
    def assign_score_of(val)
      if val.instance_of?(String)
        val.bytesize
      elsif val.instance_of?(Array) || val.instance_of?(Hash)
        sum = 1
        # Uses #each to avoid extra allocations.
        val.each { |child| sum += assign_score_of(child) }
        sum
      else
        1
      end
  end
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+  Template.register_tag('assign'.freeze, Assign)
      def children
        [@node.from]
      end
    end
  end
  Template.register_tag('assign', Assign)
 end
--- a/lib/liquid/tags/break.rb
+++ b/lib/liquid/tags/break.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Break tag to be used to break out of a for loop.
  #
  # == Basic Usage:
@@ -11,13 +10,12 @@ module Liquid
  #    {% endfor %}
  #
  class Break < Tag
    INTERRUPT = BreakInterrupt.new.freeze
-    def render_to_output_buffer(context, output)
+    def interrupt
-      context.push_interrupt(INTERRUPT)
+      BreakInterrupt.new
      output
    end
    end
-  Template.register_tag('break', Break)
+  end
  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,18 +16,17 @@ module Liquid
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to = $1
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.capture")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
      end
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      context.resource_limits.with_capture do
+      output = super
-        capture_output = render(context)
+      context.scopes.last[@to] = output
-        context.scopes.last[@to] = capture_output
+      context.resource_limits.assign_score += output.length
-      end
+      ''.freeze
      output
    end
    def blank?
@@ -37,5 +34,5 @@ module Liquid
    end
  end
-  Template.register_tag('capture', Capture)
+  Template.register_tag('capture'.freeze, Capture)
 end
--- a/lib/liquid/tags/case.rb
+++ b/lib/liquid/tags/case.rb
@@ -1,28 +1,23 @@
 # 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 = new_body
+      body = BlockBody.new
-      body = @blocks.last.attachment while parse_body(body, tokens)
+      while more = parse_body(body, tokens)
-      if blank?
+        body = @blocks.last.attachment
        @blocks.each { |condition| condition.attachment.remove_blank_strings }
      end
    end
@@ -32,64 +27,60 @@ module Liquid
    def unknown_tag(tag, markup, tokens)
      case tag
-      when 'when'
+      when 'when'.freeze
        record_when_condition(markup)
-      when 'else'
+      when 'else'.freeze
        record_else_condition(markup)
      else
        super
      end
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
      context.stack do
        execute_else_block = true
        output = ''
        @blocks.each do |block|
          if block.else?
-          block.attachment.render_to_output_buffer(context, output) if execute_else_block
+            return block.attachment.render(context) if execute_else_block
          elsif block.evaluate(context)
            execute_else_block = false
-          block.attachment.render_to_output_buffer(context, output)
+            output << block.attachment.render(context)
          end
        end
        output
      end
    end
    private
    def record_when_condition(markup)
-      body = new_body
+      body = BlockBody.new
      while markup
-        unless markup =~ WhenSyntax
+        if not markup =~ WhenSyntax
-          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
        end
-        markup = Regexp.last_match(2)
+        markup = $2
-        block = Condition.new(@left, '==', Condition.parse_expression(Regexp.last_match(1)))
+        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
        block.attach(body)
        @blocks << block
      end
    end
    def record_else_condition(markup)
-      unless markup.strip.empty?
+      if not markup.strip.empty?
-        raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
      end
      block = ElseCondition.new
-      block.attach(new_body)
+      block.attach(BlockBody.new)
      @blocks << block
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [@node.left] + @node.blocks
      end
    end
  end
-  Template.register_tag('case', Case)
+  Template.register_tag('case'.freeze, Case)
 end
--- a/lib/liquid/tags/comment.rb
+++ b/lib/liquid/tags/comment.rb
@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 module Liquid
  class Comment < Block
-    def render_to_output_buffer(_context, output)
+    def render(context)
-      output
+      ''.freeze
    end
-    def unknown_tag(_tag, _markup, _tokens)
+    def unknown_tag(tag, markup, tokens)
    end
    def blank?
@@ -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 interrupt
-
+      ContinueInterrupt.new
    def render_to_output_buffer(context, output)
      context.push_interrupt(INTERRUPT)
      output
    end
  end
-  Template.register_tag('continue', Continue)
+  Template.register_tag('continue'.freeze, Continue)
 end
--- 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))
+        @variables = variables_from_string($2)
-        @name      = Expression.parse(Regexp.last_match(1))
+        @name = Expression.parse($1)
      when SimpleSyntax
        @variables = variables_from_string(markup)
        @name = @variables.to_s
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
      end
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      context.registers[:cycle] ||= {}
+      context.registers[:cycle] ||= Hash.new(0)
      context.stack do
        key = context.evaluate(@name)
-      iteration = context.registers[:cycle][key].to_i
+        iteration = context.registers[:cycle][key]
-
+        result = context.evaluate(@variables[iteration])
      val = context.evaluate(@variables[iteration])
      if val.is_a?(Array)
        val = val.join
      elsif !val.is_a?(String)
        val = val.to_s
      end
      output << val
        iteration += 1
        iteration  = 0  if iteration >= @variables.size
        context.registers[:cycle][key] = iteration
-      output
+        result
      end
    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,6 +1,5 @@
 # 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
  #     multiple instantiations of the template.
@@ -25,14 +24,15 @@ module Liquid
      @variable = markup.strip
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
      value = context.environments.first[@variable] ||= 0
-      value -= 1
+      value = value - 1
      context.environments.first[@variable] = value
-      output << value.to_s
+      value.to_s
      output
    end
    end
-  Template.register_tag('decrement', Decrement)
+    private
  end
  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,6 +1,5 @@
 # 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 +24,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,24 +47,16 @@ module Liquid
  class For < Block
    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
    attr_reader :collection_name, :variable_name, :limit, :from
    def initialize(tag_name, markup, options)
      super
      @from = @limit = nil
      parse_with_selected_parser(markup)
-      @for_block = new_body
+      @for_block = BlockBody.new
      @else_block = nil
    end
    def parse(tokens)
-      if parse_body(@for_block, tokens)
+      if more = parse_body(@for_block, tokens)
        parse_body(@else_block, tokens)
      end
      if blank?
        @for_block.remove_blank_strings
        @else_block&.remove_blank_strings
      end
    end
    def nodelist
@@ -73,53 +64,100 @@ module Liquid
    end
    def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'
+      return super unless tag == 'else'.freeze
-      @else_block = new_body
+      @else_block = BlockBody.new
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      segment = collection_segment(context)
+      context.registers[:for] ||= Hash.new(0)
-      if segment.empty?
+      collection = context.evaluate(@collection_name)
-        render_else(context, output)
+      collection = collection.to_a if collection.is_a?(Range)
      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
      return render_else(context) unless iterable?(collection)
      from = if @from == :continue
        context.registers[:for][@name].to_i
      else
-        render_segment(context, output, segment)
+        context.evaluate(@from).to_i
      end
-      output
+      limit = context.evaluate(@limit)
      to    = limit ? limit.to_i + from : nil
      segment = Utils.slice_collection(collection, from, to)
      return render_else(context) if segment.empty?
      segment.reverse! if @reversed
      result = ''
      length = segment.length
      # Store our progress through the collection for the continue flag
      context.registers[:for][@name] = from + segment.length
      parent_loop = context['forloop'.freeze]
      context.stack do
        segment.each_with_index do |item, index|
          context[@variable_name] = item
          context['forloop'.freeze] = {
            'name'.freeze       => @name,
            'length'.freeze     => length,
            'index'.freeze      => index + 1,
            'index0'.freeze     => index,
            'rindex'.freeze     => length - index,
            'rindex0'.freeze    => length - index - 1,
            'first'.freeze      => (index == 0),
            'last'.freeze       => (index == length - 1),
            'parentloop'.freeze => parent_loop
          }
          result << @for_block.render(context)
          # Handle any interrupts if they exist.
          if context.has_interrupt?
            interrupt = context.pop_interrupt
            break if interrupt.is_a? BreakInterrupt
            next if interrupt.is_a? ContinueInterrupt
          end
        end
      end
      result
    end
    protected
    def lax_parse(markup)
      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
+        @variable_name = $1
-        collection_name  = Regexp.last_match(2)
+        collection_name = $2
-        @reversed        = !!Regexp.last_match(3)
+        @reversed = $3
        @name = "#{@variable_name}-#{collection_name}"
        @collection_name = Expression.parse(collection_name)
        markup.scan(TagAttributes) do |key, value|
          set_attribute(key, value)
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.for")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
      end
    end
    def strict_parse(markup)
      p = Parser.new(markup)
      @variable_name = p.consume(:id)
-      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
      collection_name = p.expression
      @collection_name = Expression.parse(collection_name)
      @name = "#{@variable_name}-#{collection_name}"
-      @reversed = p.id?('reversed')
+      @collection_name = Expression.parse(collection_name)
      @reversed = p.id?('reversed'.freeze)
      while p.look(:id) && p.look(:colon, 1)
-        unless (attribute = p.id?('limit') || p.id?('offset'))
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
-          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
        end
        p.consume
        set_attribute(attribute, p.expression)
@@ -129,96 +167,27 @@ module Liquid
    private
    def collection_segment(context)
      offsets = context.registers[:for] ||= {}
      from = if @from == :continue
        offsets[@name].to_i
      else
        from_value = context.evaluate(@from)
        if from_value.nil?
          0
        else
          Utils.to_integer(from_value)
        end
      end
      collection = context.evaluate(@collection_name)
      collection = collection.to_a if collection.is_a?(Range)
      limit_value = context.evaluate(@limit)
      to = if limit_value.nil?
        nil
      else
        Utils.to_integer(limit_value) + from
      end
      segment = Utils.slice_collection(collection, from, to)
      segment.reverse! if @reversed
      offsets[@name] = from + segment.length
      segment
    end
    def render_segment(context, output, segment)
      for_stack = context.registers[:for_stack] ||= []
      length    = segment.length
      context.stack do
        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
        for_stack.push(loop_vars)
        begin
          context['forloop'] = loop_vars
          segment.each do |item|
            context[@variable_name] = item
            @for_block.render_to_output_buffer(context, output)
            loop_vars.send(:increment!)
            # Handle any interrupts if they exist.
            next unless context.interrupt?
            interrupt = context.pop_interrupt
            break if interrupt.is_a?(BreakInterrupt)
            next if interrupt.is_a?(ContinueInterrupt)
          end
        ensure
          for_stack.pop
        end
      end
      output
    end
    def set_attribute(key, expr)
      case key
-      when 'offset'
+      when 'offset'.freeze
-        @from = if expr == 'continue'
+        @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)
+    def render_else(context)
-      if @else_block
+      @else_block ? @else_block.render(context) : ''.freeze
-        @else_block.render_to_output_buffer(context, output)
+    end
-      else
+
-        output
+    def iterable?(collection)
      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
    end
  end
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+  Template.register_tag('for'.freeze, For)
      def children
        (super + [@node.limit, @node.from, @node.collection_name]).compact
      end
    end
  end
  Template.register_tag('for', 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
  #
@@ -14,76 +12,68 @@ module Liquid
  class If < Block
    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS       = %w(and or).freeze
+    BOOLEAN_OPERATORS = %w(and or)
    attr_reader :blocks
    def initialize(tag_name, markup, options)
      super
      @blocks = []
-      push_block('if', markup)
+      push_block('if'.freeze, markup)
    end
    def parse(tokens)
      while more = parse_body(@blocks.last.attachment, tokens)
      end
    end
    def nodelist
      @blocks.map(&:attachment)
    end
    def parse(tokens)
      while parse_body(@blocks.last.attachment, tokens)
      end
      if blank?
        @blocks.each { |condition| condition.attachment.remove_blank_strings }
      end
    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)
+    def render(context)
      context.stack do
        @blocks.each do |block|
          if block.evaluate(context)
-          return block.attachment.render_to_output_buffer(context, output)
+            return block.attachment.render(context)
          end
        end
-
+        ''.freeze
-      output
+      end
    end
    private
      def push_block(tag, markup)
-      block = if tag == 'else'
+        block = if tag == 'else'.freeze
          ElseCondition.new
        else
          parse_with_selected_parser(markup)
        end
        @blocks.push(block)
-      block.attach(new_body)
+        block.attach(BlockBody.new)
    end
    def parse_expression(markup)
      Condition.parse_expression(markup)
      end
      def lax_parse(markup)
        expressions = markup.scan(ExpressionsAndOperators)
-      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
-      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+        condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
-      until expressions.empty?
+        while not expressions.empty?
          operator = expressions.pop.to_s.strip
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
-        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
+          new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
          new_condition.send(operator, condition)
          condition = new_condition
        end
@@ -93,38 +83,29 @@ module Liquid
      def strict_parse(markup)
        p = Parser.new(markup)
-      condition = parse_binary_comparisons(p)
+
        condition = parse_comparison(p)
        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
          new_cond = parse_comparison(p)
          new_cond.send(op, condition)
          condition = new_cond
        end
        p.consume(:end_of_string)
        condition
      end
    def parse_binary_comparisons(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
      end
      first_condition
    end
      def parse_comparison(p)
-      a = parse_expression(p.expression)
+        a = Expression.parse(p.expression)
-      if (op = p.consume?(:comparison))
+        if op = p.consume?(:comparison)
-        b = parse_expression(p.expression)
+          b = Expression.parse(p.expression)
          Condition.new(a, op, b)
        else
          Condition.new(a)
        end
      end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        @node.blocks
      end
    end
  end
-  Template.register_tag('if', If)
+  Template.register_tag('if'.freeze, If)
 end
--- a/lib/liquid/tags/ifchanged.rb
+++ b/lib/liquid/tags/ifchanged.rb
@@ -1,19 +1,20 @@
 # frozen_string_literal: true
 module Liquid
  class Ifchanged < Block
    def render_to_output_buffer(context, output)
      block_output = +''
      super(context, block_output)
-      if block_output != context.registers[:ifchanged]
+    def render(context)
-        context.registers[:ifchanged] = block_output
+      context.stack do
        output << block_output
      end
        output = super
        if output != context.registers[:ifchanged]
          context.registers[:ifchanged] = output
          output
        else
          ''.freeze
        end
      end
    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,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Include allows templates to relate with other templates
  #
  # Simply include another template:
@@ -16,24 +15,19 @@ module Liquid
  #   {% include 'product' for products %}
  #
  class Include < Tag
-    prepend Tag::Disableable
+    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
    Syntax = SYNTAX
    attr_reader :template_name_expr, :variable_name_expr, :attributes
    def initialize(tag_name, markup, options)
      super
-      if markup =~ SYNTAX
+      if markup =~ Syntax
-        template_name = Regexp.last_match(1)
+        template_name = $1
-        variable_name = Regexp.last_match(3)
+        variable_name = $3
-        @alias_name         = Regexp.last_match(5)
+        @variable_name = Expression.parse(variable_name || template_name[1..-2])
-        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
+        @context_variable_name = template_name[1..-2].split('/'.freeze).last
-        @template_name_expr = Expression.parse(template_name)
+        @template_name = Expression.parse(template_name)
        @attributes    = {}
        markup.scan(TagAttributes) do |key, value|
@@ -41,71 +35,65 @@ module Liquid
        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)
+    def parse(tokens)
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      template_name = context.evaluate(@template_name_expr)
+      partial = load_cached_partial(context)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
+      variable = context.evaluate(@variable_name)
      partial = PartialCache.load(
        template_name,
        context: context,
        parse_context: parse_context
      )
      context_variable_name = @alias_name || template_name.split('/').last
      variable = if @variable_name_expr
        context.evaluate(@variable_name_expr)
      else
        context.find_variable(template_name, raise_on_not_found: false)
      end
      old_template_name = context.template_name
      old_partial       = context.partial
      begin
        context.template_name = template_name
        context.partial       = true
      context.stack do
        @attributes.each do |key, value|
          context[key] = context.evaluate(value)
        end
        if variable.is_a?(Array)
-            variable.each do |var|
+          variable.collect do |var|
-              context[context_variable_name] = var
+            context[@context_variable_name] = var
-              partial.render_to_output_buffer(context, output)
+            partial.render(context)
          end
        else
-            context[context_variable_name] = variable
+          context[@context_variable_name] = variable
-            partial.render_to_output_buffer(context, output)
+          partial.render(context)
          end
        end
      ensure
        context.template_name = old_template_name
        context.partial       = old_partial
      end
      output
    end
    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
        end
      end
    end
-  Template.register_tag('include', Include)
+    private
      def load_cached_partial(context)
        cached_partials = context.registers[:cached_partials] || {}
        template_name = context.evaluate(@template_name)
        if cached = cached_partials[template_name]
          return cached
        end
        source = read_template_from_file_system(context)
        partial = Liquid::Template.parse(source, pass_options)
        cached_partials[template_name] = partial
        context.registers[:cached_partials] = cached_partials
        partial
      end
      def read_template_from_file_system(context)
        file_system = context.registers[:file_system] || Liquid::Template.file_system
        file_system.read_template_file(context.evaluate(@template_name))
      end
      def pass_options
        dont_pass = @options[:include_options_blacklist]
        return {locale: @options[:locale]} if dont_pass == true
        opts = @options.merge(included: true, include_options_blacklist: false)
        if dont_pass.is_a?(Array)
          dont_pass.each {|o| opts.delete(o)}
        end
        opts
      end
  end
  Template.register_tag('include'.freeze, Include)
 end
--- 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
-
+      value.to_s
      output << value.to_s
      output
    end
  end
-  Template.register_tag('increment', Increment)
+  Template.register_tag('increment'.freeze, Increment)
 end
--- a/lib/liquid/tags/raw.rb
+++ b/lib/liquid/tags/raw.rb
@@ -1,32 +1,20 @@
 # frozen_string_literal: true
 module Liquid
  class Raw < Block
    Syntax = /\A\s*\z/
    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
    def initialize(tag_name, markup, parse_context)
      super
      ensure_valid_markup(tag_name, markup, parse_context)
    end
    def parse(tokens)
-      @body = +''
+      @body = ''
-      while (token = tokens.shift)
+      while token = tokens.shift
        if token =~ FullTokenPossiblyInvalid
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
+          @body << $1 if $1 != "".freeze
-          return if block_delimiter == Regexp.last_match(2)
+          return if block_delimiter == $2
        end
        @body << token if not token.empty?
      end
        @body << token unless token.empty?
    end
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+    def render(context)
-    end
+      @body
    def render_to_output_buffer(_context, output)
      output << @body
      output
    end
    def nodelist
@@ -36,15 +24,7 @@ module Liquid
    def blank?
      @body.empty?
    end
    protected
    def ensure_valid_markup(tag_name, markup, parse_context)
      unless Syntax.match?(markup)
        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args", tag: tag_name)
      end
    end
  end
-  Template.register_tag('raw', 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,72 @@
 # frozen_string_literal: true
 module Liquid
  class TableRow < Block
    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
    attr_reader :variable_name, :collection_name, :attributes
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @variable_name   = Regexp.last_match(1)
+        @variable_name = $1
-        @collection_name = Expression.parse(Regexp.last_match(2))
+        @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)
+    def render(context)
-      (collection = context.evaluate(@collection_name)) || (return '')
+      collection = context.evaluate(@collection_name) or return ''.freeze
-      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
+      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
-      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil
+      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
      collection = Utils.slice_collection(collection, from, to)
      length = collection.length
-      cols = context.evaluate(@attributes['cols']).to_i
+      cols = context.evaluate(@attributes['cols'.freeze]).to_i
-      output << "<tr class=\"row1\">\n"
+      row = 1
      col = 0
      result = "<tr class=\"row1\">\n"
      context.stack do
        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
        context['tablerowloop'] = tablerowloop
-        collection.each do |item|
+        collection.each_with_index do |item, index|
          context[@variable_name] = item
          context['tablerowloop'.freeze] = {
            'length'.freeze    => length,
            'index'.freeze     => index + 1,
            'index0'.freeze    => index,
            'col'.freeze       => col + 1,
            'col0'.freeze      => col,
            'rindex'.freeze    => length - index,
            'rindex0'.freeze   => length - index - 1,
            'first'.freeze     => (index == 0),
            'last'.freeze      => (index == length - 1),
            'col_first'.freeze => (col == 0),
            'col_last'.freeze  => (col == cols - 1)
          }
          output << "<td class=\"col#{tablerowloop.col}\">"
          super
          output << '</td>'
-          if tablerowloop.col_last && !tablerowloop.last
+          col += 1
-            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
+
          result << "<td class=\"col#{col}\">" << super << '</td>'
          if col == cols and (index != length - 1)
            col  = 0
            row += 1
            result << "</tr>\n<tr class=\"row#{row}\">"
          end
-          tablerowloop.send(:increment!)
+        end
      end
      result << "</tr>\n"
      result
    end
  end
-      output << "</tr>\n"
+  Template.register_tag('tablerow'.freeze, TableRow)
      output
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        super + @node.attributes.values + [@node.collection_name]
      end
    end
  end
  Template.register_tag('tablerow', TableRow)
 end
--- a/lib/liquid/tags/unless.rb
+++ b/lib/liquid/tags/unless.rb
@@ -1,6 +1,4 @@
-# frozen_string_literal: true
+require File.dirname(__FILE__) + '/if'
 require_relative 'if'
 module Liquid
  # Unless is a conditional just like 'if' but works on the inverse logic.
@@ -8,23 +6,26 @@ module Liquid
  #   {% unless x < 0 %} x is greater than zero {% endunless %}
  #
  class Unless < If
-    def render_to_output_buffer(context, output)
+    def render(context)
      context.stack do
        # First condition is interpreted backwards ( if not )
        first_block = @blocks.first
        unless first_block.evaluate(context)
-        return first_block.attachment.render_to_output_buffer(context, output)
+          return first_block.attachment.render(context)
        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)
+            return block.attachment.render(context)
          end
        end
-      output
+        ''.freeze
      end
    end
  end
-  Template.register_tag('unless', Unless)
+  Template.register_tag('unless'.freeze, Unless)
 end
--- a/lib/liquid/template.rb
+++ b/lib/liquid/template.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Templates are central to liquid.
  # Interpretating templates is a two step process. First you compile the
  # source code you got. During compile time some extensive error checking is performed.
@@ -15,19 +14,23 @@ module Liquid
  #   template.render('user_name' => 'bob')
  #
  class Template
    DEFAULT_OPTIONS = {
      :locale => I18n.new
    }
    attr_accessor :root
-    attr_reader :resource_limits, :warnings
+    attr_reader :resource_limits
    @@file_system = BlankFileSystem.new
    class TagRegistry
      include Enumerable
      def initialize
        @tags  = {}
        @cache = {}
      end
      def [](tag_name)
-        return nil unless @tags.key?(tag_name)
+        return nil unless @tags.has_key?(tag_name)
        return @cache[tag_name] if Liquid.cache_classes
        lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
@@ -43,14 +46,10 @@ module Liquid
        @cache.delete(tag_name)
      end
      def each(&block)
        @tags.each(&block)
      end
      private
      def lookup_class(name)
-        Object.const_get(name)
+        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
      end
    end
@@ -61,46 +60,59 @@ module Liquid
      # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
      # :warn is the default and will give deprecation warnings when invalid syntax is used.
      # :strict will enforce correct syntax.
-      attr_accessor :error_mode
+      attr_writer :error_mode
      Template.error_mode = :lax
-      attr_accessor :default_exception_renderer
+      # Sets how strict the taint checker should be.
-      Template.default_exception_renderer = lambda do |exception|
+      # :lax is the default, and ignores the taint flag completely
-        exception
+      # :warn adds a warning, but does not interrupt the rendering
      # :error raises an error when tainted output is used
      attr_writer :taint_mode
      def file_system
        @@file_system
      end
-      attr_accessor :file_system
+      def file_system=(obj)
-      Template.file_system = BlankFileSystem.new
+        @@file_system = obj
-
+      end
      attr_accessor :tags
      Template.tags = TagRegistry.new
      private :tags=
      def register_tag(name, klass)
        tags[name.to_s] = klass
      end
      def tags
        @tags ||= TagRegistry.new
      end
      def error_mode
        @error_mode || :lax
      end
      def taint_mode
        @taint_mode || :lax
      end
      # Pass a module with filter methods which should be available
      # to all liquid views. Good for registering the standard library
      def register_filter(mod)
-        StrainerFactory.add_global_filter(mod)
+        Strainer.global_filter(mod)
      end
-      attr_accessor :default_resource_limits
+      def default_resource_limits
-      Template.default_resource_limits = {}
+        @default_resource_limits ||= {}
-      private :default_resource_limits=
+      end
      # creates a new <tt>Template</tt> object from liquid source code
      # To enable profiling, pass in <tt>profile: true</tt> as an option.
      # See Liquid::Profiler for more information
      def parse(source, options = {})
-        new.parse(source, options)
+        template = Template.new
        template.parse(source, options)
      end
    end
    def initialize
-      @rethrow_errors  = false
+      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
      @resource_limits = ResourceLimits.new(Template.default_resource_limits)
    end
    # Parse source code.
@@ -109,12 +121,16 @@ module Liquid
      @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), DEFAULT_OPTIONS.merge(options))
-      @root         = Document.parse(tokenize(source), parse_context)
+      @warnings = nil
      @warnings     = parse_context.warnings
      self
    end
    def warnings
      return [] unless @root
      @warnings ||= @root.warnings
    end
    def registers
      @registers ||= {}
    end
@@ -146,14 +162,14 @@ 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_handler = ->(e) { true }
        end
        c
@@ -168,21 +184,24 @@ 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|
+        if options[:registers].is_a?(Hash)
-          context_register[key] = register
+          self.registers.merge!(options[:registers])
        end
-        apply_options_to_context(context, options)
+        if options[:filters]
-      when Module, Array
+          context.add_filters(options[:filters])
        end
        if options[:exception_handler]
          context.exception_handler = options[:exception_handler]
        end
      when Module
        context.add_filters(args.pop)
      when Array
        context.add_filters(args.pop)
      end
@@ -192,9 +211,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
+        result = with_profiling do
-          @root.render_to_output_buffer(context, output || +'')
+          @root.render(context)
        end
        result.respond_to?(:join) ? result.join : result
      rescue Liquid::MemoryError => e
        context.handle_error(e)
      ensure
@@ -207,21 +227,37 @@ module Liquid
      render(*args)
    end
    def render_to_output_buffer(context, output)
      render(context, output: output)
    end
    private
    # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
    def tokenize(source)
-      Tokenizer.new(source, @line_numbers)
+      source = source.source if source.respond_to?(:source)
      return [] if source.to_s.empty?
      tokens = calculate_line_numbers(source.split(TemplateParser))
      # removes the rogue empty element at the beginning of the array
      tokens.shift if tokens[0] and tokens[0].empty?
      tokens
    end
-    def with_profiling(context)
+    def calculate_line_numbers(raw_tokens)
-      if @profiling && !context.partial
+      return raw_tokens unless @line_numbers
      current_line = 1
      raw_tokens.map do |token|
        Token.new(token, current_line).tap do
          current_line += token.count("\n")
        end
      end
    end
    def with_profiling
      if @profiling && !@options[:included]
        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
-        @profiler = Profiler.new(context.template_name)
+        @profiler = Profiler.new
        @profiler.start
        begin
@@ -233,13 +269,5 @@ module Liquid
        yield
      end
    end
    def apply_options_to_context(context, options)
      context.add_filters(options[:filters]) if options[:filters]
      context.global_filter      = options[:global_filter] if options[:global_filter]
      context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
      context.strict_variables   = options[:strict_variables] if options[:strict_variables]
      context.strict_filters     = options[:strict_filters] if options[:strict_filters]
    end
  end
 end
--- a/lib/liquid/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/token.rb
+++ b/lib/liquid/token.rb
@@ -0,0 +1,18 @@
 module Liquid
  class Token < String
    attr_reader :line_number
    def initialize(content, line_number)
      super(content)
      @line_number = line_number
    end
    def raw
      "<raw>"
    end
    def child(string)
      Token.new(string, @line_number)
    end
  end
 end
--- a/lib/liquid/tokenizer.rb
+++ b/lib/liquid/tokenizer.rb
@@ -1,39 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class Tokenizer
    attr_reader :line_number, :for_liquid_tag
    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
    end
    def shift
      (token = @tokens.shift) || return
      if @line_number
        @line_number += @for_liquid_tag ? 1 : token.count("\n")
      end
      token
    end
    private
    def tokenize
      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
    end
  end
 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,26 +1,27 @@
 # frozen_string_literal: true
 module Liquid
  module Utils
    def self.slice_collection(collection, from, to)
-      if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
+      if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
        collection.load_slice(from, to)
      else
        slice_collection_using_each(collection, from, to)
      end
    end
    def self.non_blank_string?(collection)
      collection.is_a?(String) && collection != ''.freeze
    end
    def self.slice_collection_using_each(collection, from, to)
      segments = []
      index = 0
      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      if collection.is_a?(String)
+      return [collection] if non_blank_string?(collection)
        return collection.empty? ? [] : [collection]
      end
      return [] unless collection.respond_to?(:each)
      collection.each do |item|
        if to && to <= index
          break
        end
@@ -34,52 +35,5 @@ module Liquid
      segments
    end
    def self.to_integer(num)
      return num if num.is_a?(Integer)
      num = num.to_s
      begin
        Integer(num)
      rescue ::ArgumentError
        raise Liquid::ArgumentError, "invalid integer"
      end
    end
    def self.to_number(obj)
      case obj
      when Float
        BigDecimal(obj.to_s)
      when Numeric
        obj
      when String
        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
      else
        if obj.respond_to?(:to_number)
          obj.to_number
        else
          0
        end
      end
    end
    def self.to_date(obj)
      return obj if obj.respond_to?(:strftime)
      if obj.is_a?(String)
        return nil if obj.empty?
        obj = obj.downcase
      end
      case obj
      when 'now', 'today'
        Time.now
      when /\A\d+\z/, Integer
        Time.at(obj.to_i)
      when String
        Time.parse(obj)
      end
    rescue ::ArgumentError
      nil
    end
  end
 end
--- a/lib/liquid/variable.rb
+++ b/lib/liquid/variable.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Holds variables. Variables are only loaded "just in time"
  # and are not evaluated as part of the render stage
  #
@@ -12,23 +11,15 @@ module Liquid
  #   {{ user | link }}
  #
  class Variable
    FilterMarkupRegex        = /#{FilterSeparator}\s*(.*)/om
    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    FilterArgsRegex          = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
+    attr_accessor :filters, :name, :warnings
-    JustTagAttributes        = /\A#{TagAttributes}\z/o
+    attr_accessor :line_number
    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
    attr_accessor :filters, :name, :line_number
    attr_reader :parse_context
    alias_method :options, :parse_context
    include ParserSwitching
-    def initialize(markup, parse_context)
+    def initialize(markup, options = {})
      @markup  = markup
      @name    = nil
-      @parse_context = parse_context
+      @options = options || {}
      @line_number   = parse_context.line_number
      parse_with_selected_parser(markup)
    end
@@ -42,25 +33,28 @@ module Liquid
    end
    def lax_parse(markup)
-      @filters = []
+      @filters ||= []
-      return unless markup =~ MarkupWithQuotedFragment
+      @filters.clear
-
+      if markup =~ /(#{QuotedFragment})(.*)/om
-      name_markup   = Regexp.last_match(1)
+        name_markup = $1
-      filter_markup = Regexp.last_match(2)
+        filter_markup = $2
        @name = Expression.parse(name_markup)
-      if filter_markup =~ FilterMarkupRegex
+        if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
-        filters = Regexp.last_match(1).scan(FilterParser)
+          filters = $1.scan(FilterParser)
          filters.each do |f|
-          next unless f =~ /\w+/
+            if 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
        end
      end
    end
    def strict_parse(markup)
-      @filters = []
+      @filters ||= []
      @filters.clear
      p = Parser.new(markup)
      @name = Expression.parse(p.expression)
@@ -76,55 +70,33 @@ module Liquid
      # first argument
      filterargs = [p.argument]
      # followed by comma separated others
-      filterargs << p.argument while p.consume?(:comma)
+      while p.consume?(:comma)
        filterargs << p.argument
      end
      filterargs
    end
    def render(context)
-      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
+      @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        context.invoke(filter_name, output, *filter_args)
+        output = context.invoke(filter_name, output, *filter_args)
-      end
+      end.tap{ |obj| taint_check(obj) }
      context.apply_global_filter(obj)
    end
    def render_to_output_buffer(context, output)
      obj = render(context)
      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
      []
    end
    private
    def parse_filter_expressions(filter_name, unparsed_args)
      filter_args = []
-      keyword_args = nil
+      keyword_args = {}
      unparsed_args.each do |a|
-        if (matches = a.match(JustTagAttributes))
+        if matches = a.match(/\A#{TagAttributes}\z/o)
          keyword_args           ||= {}
          keyword_args[matches[1]] = Expression.parse(matches[2])
        else
          filter_args << Expression.parse(a)
        end
      end
      result = [filter_name, filter_args]
-      result << keyword_args if keyword_args
+      result << keyword_args unless keyword_args.empty?
      result
    end
@@ -140,9 +112,17 @@ module Liquid
      parsed_args
    end
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+    def taint_check(obj)
-      def children
+      if obj.tainted?
-        [@node.name] + @node.filters.flatten
+        @markup =~ QuotedFragment
        name = Regexp.last_match(0)
        case Template.taint_mode
        when :warn
          @warnings ||= []
          @warnings << "variable '#{name}' is tainted and was not escaped"
        when :error
          raise TaintedError, "Error - variable '#{name}' is tainted and was not escaped"
        end
      end
    end
  end
--- 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
@@ -12,21 +10,20 @@ module Liquid
    end
    def initialize(markup)
-      lookups = markup.scan(VariableParser)
+      @lookups = markup.scan(VariableParser)
-      name = lookups.shift
+      name = @lookups.shift
      if name =~ SQUARE_BRACKETED
-        name = Expression.parse(Regexp.last_match(1))
+        name = Expression.parse($1)
      end
      @name = name
      @lookups       = lookups
      @command_flags = 0
      @lookups.each_index do |i|
-        lookup = lookups[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
@@ -43,7 +40,7 @@ module Liquid
        # If object is a hash- or array-like object we look for the
        # presence of the key and if its available we return it
        if object.respond_to?(:[]) &&
-            ((object.respond_to?(:key?) && object.key?(key)) ||
+          ((object.respond_to?(:has_key?) && object.has_key?(key)) ||
           (object.respond_to?(:fetch) && key.is_a?(Integer)))
          # if its a proc we will replace the entry with the proc
@@ -57,11 +54,9 @@ module Liquid
          object = object.send(key).to_liquid
          # No key was present with the desired value and it wasn't one of the directly supported
-          # keywords either. The only thing we got left is to return nil or
+          # keywords either. The only thing we got left is to return nil
          # raise an exception if `strict_variables` option is set to true
        else
-          return nil unless context.strict_variables
+          return nil
          raise Liquid::UndefinedVariable, "undefined variable #{key}"
        end
        # If we are dealing with a drop here we have to
@@ -72,7 +67,7 @@ module Liquid
    end
    def ==(other)
-      self.class == other.class && state == other.state
+      self.class == other.class && self.state == other.state
    end
    protected
@@ -80,11 +75,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.alpha"
 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)
+$:.unshift lib unless $:.include?(lib)
 require "liquid/version"
@@ -17,16 +15,15 @@ Gem::Specification.new do |s|
  s.license     = "MIT"
  #s.description = "A secure, non-evaling end user template engine with aesthetic markup."
  s.required_ruby_version     = ">= 2.4.0"
  s.required_rubygems_version = ">= 1.3.7"
  s.test_files  = Dir.glob("{test}/**/*")
-  s.files       = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
+  s.files       = Dir.glob("{lib}/**/*") + %w(MIT-LICENSE README.md)
  s.extra_rdoc_files  = ["History.md", "README.md"]
  s.require_path = "lib"
-  s.add_development_dependency('rake', '~> 13.0')
+  s.add_development_dependency 'rake'
-  s.add_development_dependency('minitest')
+  s.add_development_dependency 'minitest'
 end
--- a/performance/benchmark.rb
+++ b/performance/benchmark.rb
@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 require 'benchmark/ips'
-require_relative 'theme_runner'
+require File.dirname(__FILE__) + '/theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 Benchmark.ips do |x|
-  x.time   = 10
+  x.time = 60
  x.warmup = 5
  puts
@@ -15,6 +13,5 @@ Benchmark.ips do |x|
  puts
  x.report("parse:") { profiler.compile }
-  x.report("render:") { profiler.render }
+  x.report("parse & run:") { profiler.run }
  x.report("parse & render:") { profiler.run }
 end
--- a/performance/memory.rb
+++ b/performance/memory.rb
@@ -0,0 +1,19 @@
 at_exit do
  p 'Objects distribution:'
  require 'pp'
  pp ObjectSpace.count_objects
 end
 require 'allocation_tracer' rescue fail("install allocation_tracer extension/gem")
 require File.dirname(__FILE__) + '/theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 require 'allocation_tracer/trace'
 puts "Profiling memory usage..."
 200.times do
  profiler.run
 end
--- 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,21 +1,19 @@
-# frozen_string_literal: true
+require 'stackprof' rescue fail("install stackprof extension/gem")
-
+require File.dirname(__FILE__) + '/theme_runner'
 require 'stackprof'
 require_relative 'theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run
 [:cpu, :object].each do |profile_type|
-  puts "Profiling in #{profile_type} mode..."
+  puts "Profiling in #{profile_type.to_s} mode..."
  results = StackProf.run(mode: profile_type) do
    200.times do
      profiler.run
    end
  end
-  if profile_type == :cpu && (graph_filename = ENV['GRAPH_FILENAME'])
+  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
    File.open(graph_filename, 'w') do |f|
      StackProf::Report.new(results).print_graphviz(nil, f)
    end
--- 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)
+      @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
@@ -23,15 +21,13 @@ class CommentForm < Liquid::Block
        'errors' => context['comment.errors'],
        'author' => context['comment.author'],
        'email'  => context['comment.email'],
-        'body' => context['comment.body'],
+        'body'   => context['comment.body']
      }
-
+      wrap_in_form(article, render_all(@nodelist, context))
      output << wrap_in_form(article, render_all(@nodelist, context, output))
      output
    end
  end
  def wrap_in_form(article, input)
-    %(<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>)
+    %Q{<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>}
  end
 end
--- a/performance/shopify/database.rb
+++ b/performance/shopify/database.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 require 'yaml'
 module Database
@@ -7,7 +5,7 @@ module Database
  # to liquid as assigns. All this is based on Shopify
  def self.tables
    @tables ||= begin
-      db = YAML.load_file("#{__dir__}/vision.database.yml")
+      db = YAML.load_file(File.dirname(__FILE__) + '/vision.database.yml')
      # From vision source
      db['products'].each do |product|
@@ -18,10 +16,9 @@ module Database
      end
      # key the tables by handles, as this is how liquid expects it.
-      db = db.each_with_object({}) do |(key, values), assigns|
+      db = db.inject({}) do |assigns, (key, values)|
-        assigns[key] = values.each_with_object({}) do |v, h|
+        assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; }
-          h[v['handle']] = v
+        assigns
        end
      end
      # Some standard direct accessors so that the specialized templates
@@ -32,9 +29,9 @@ module Database
      db['article']    = db['blog']['articles'].first
      db['cart']       = {
-        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum + item['line_price'] * item['quantity'] },
+        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
-        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum + item['quantity'] },
+        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
-        'items' => db['line_items'].values,
+        'items'       => db['line_items'].values
      }
      db
@@ -42,7 +39,7 @@ module Database
  end
 end
-if __FILE__ == $PROGRAM_NAME
+if __FILE__ == $0
-  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,9 @@
 # frozen_string_literal: true
 require 'json'
 module JsonFilter
  def json(object)
-    JSON.dump(object.reject { |k, _v| k == "collections" })
+    JSON.dump(object.reject {|k,v| k == "collections" })
  end
 end
--- a/performance/shopify/liquid.rb
+++ b/performance/shopify/liquid.rb
@@ -1,21 +1,19 @@
-# frozen_string_literal: true
+$:.unshift File.dirname(__FILE__) + '/../../lib'
 require File.dirname(__FILE__) + '/../../lib/liquid'
-$LOAD_PATH.unshift(__dir__ + '/../../lib')
+require File.dirname(__FILE__) + '/comment_form'
-require_relative '../../lib/liquid'
+require File.dirname(__FILE__) + '/paginate'
 require File.dirname(__FILE__) + '/json_filter'
 require File.dirname(__FILE__) + '/money_filter'
 require File.dirname(__FILE__) + '/shop_filter'
 require File.dirname(__FILE__) + '/tag_filter'
 require File.dirname(__FILE__) + '/weight_filter'
-require_relative 'comment_form'
+Liquid::Template.register_tag 'paginate', Paginate
-require_relative 'paginate'
+Liquid::Template.register_tag 'form', CommentForm
 require_relative 'json_filter'
 require_relative 'money_filter'
 require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'
-Liquid::Template.register_tag('paginate', Paginate)
+Liquid::Template.register_filter JsonFilter
-Liquid::Template.register_tag('form', CommentForm)
+Liquid::Template.register_filter MoneyFilter
-
+Liquid::Template.register_filter WeightFilter
-Liquid::Template.register_filter(JsonFilter)
+Liquid::Template.register_filter ShopFilter
-Liquid::Template.register_filter(MoneyFilter)
+Liquid::Template.register_filter TagFilter
 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,13 @@
 # frozen_string_literal: true
 module MoneyFilter
  def money_with_currency(money)
    return '' if money.nil?
-    format("$ %.2f USD", money / 100.0)
+    sprintf("$ %.2f USD", money/100.0)
  end
  def money(money)
    return '' if money.nil?
-    format("$ %.2f", money / 100.0)
+    sprintf("$ %.2f", money/100.0)
  end
  private
--- a/performance/shopify/paginate.rb
+++ b/performance/shopify/paginate.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 class Paginate < Liquid::Block
  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
@@ -7,9 +5,9 @@ class Paginate < Liquid::Block
    super
    if markup =~ Syntax
-      @collection_name = Regexp.last_match(1)
+      @collection_name = $1
-      @page_size       = if Regexp.last_match(2)
+      @page_size = if $2
-        Regexp.last_match(3).to_i
+        $3.to_i
      else
        20
      end
@@ -19,11 +17,11 @@ 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
@@ -32,14 +30,14 @@ class Paginate < Liquid::Block
      pagination = {
        'page_size'      => @page_size,
        'current_page'   => 5,
-        'current_offset' => @page_size * 5,
+        'current_offset' => @page_size * 5
      }
      context['paginate'] = pagination
      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
@@ -53,13 +51,14 @@ class Paginate < Liquid::Block
      if page_count > 2
        1.upto(page_count-1) do |page|
          if current_page == page
            pagination['parts'] << no_link(page)
          elsif page == 1
            pagination['parts'] << link(page, page)
          elsif page == page_count -1
            pagination['parts'] << link(page, page)
-          elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
+          elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
            next if hellip_break
            pagination['parts'] << no_link('&hellip;')
            hellip_break = true
--- a/performance/shopify/shop_filter.rb
+++ b/performance/shopify/shop_filter.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module ShopFilter
  def asset_url(input)
    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
  end
@@ -22,16 +21,16 @@ module ShopFilter
  end
  def link_to(link, url, title="")
-    %(<a href="#{url}" title="#{title}">#{link}</a>)
+    %|<a href="#{url}" title="#{title}">#{link}</a>|
  end
  def img_tag(url, alt="")
-    %(<img src="#{url}" alt="#{alt}" />)
+    %|<img src="#{url}" alt="#{alt}" />|
  end
  def link_to_vendor(vendor)
    if vendor
-      link_to(vendor, url_for_vendor(vendor), vendor)
+      link_to vendor, url_for_vendor(vendor), vendor
    else
      'Unknown Vendor'
    end
@@ -39,7 +38,7 @@ module ShopFilter
  def link_to_type(type)
    if type
-      link_to(type, url_for_type(type), type)
+      link_to type, url_for_type(type), type
    else
      'Unknown Vendor'
    end
@@ -54,32 +53,36 @@ module ShopFilter
  end
  def product_img_url(url, style = 'small')
-    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
+
    unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
      raise ArgumentError, 'filter "size" can only be called on product images'
    end
    case style
    when 'original'
-      '/files/shops/random_number/' + url
+      return '/files/shops/random_number/' + url
    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
+      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"
    else
      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
    end
  end
  def default_pagination(paginate)
    html = []
    html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
-    paginate['parts'].each do |part|
+    for part in paginate['parts']
-      html << if part['is_link']
+
-        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+      if part['is_link']
        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
      elsif part['title'].to_i == paginate['current_page'].to_i
-        %(<span class="page current">#{part['title']}</span>)
+        html << %(<span class="page current">#{part['title']}</span>)
      else
-        %(<span class="deco">#{part['title']}</span>)
+        html << %(<span class="deco">#{part['title']}</span>)
      end
    end
    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
@@ -103,4 +106,5 @@ module ShopFilter
    result.gsub!(/\A-+/, '') if result[0] == '-'
    result
  end
 end
--- a/performance/shopify/tag_filter.rb
+++ b/performance/shopify/tag_filter.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module TagFilter
  def link_to_tag(label, tag)
    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
  end
@@ -15,11 +14,12 @@ module TagFilter
  def link_to_add_tag(label, tag)
    tags = (@context['current_tags'] + [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
  end
  def link_to_remove_tag(label, tag)
    tags = (@context['current_tags'] - [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
  end
 end
--- a/performance/shopify/weight_filter.rb
+++ b/performance/shopify/weight_filter.rb
@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 module WeightFilter
  def weight(grams)
-    format("%.2f", grams / 1000)
+    sprintf("%.2f", grams / 1000)
  end
  def weight_with_unit(grams)
    "#{weight(grams)} kg"
  end
 end
--- 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.
@@ -8,11 +6,12 @@
 # Shopify which is likely the biggest user of liquid in the world which something to the tune of several
 # million Template#render calls a day.
-require_relative 'shopify/liquid'
+require File.dirname(__FILE__) + '/shopify/liquid'
-require_relative 'shopify/database'
+require File.dirname(__FILE__) + '/shopify/database.rb'
 class ThemeRunner
  class FileSystem
    def initialize(path)
      @path = path
    end
@@ -23,100 +22,57 @@ class ThemeRunner
    end
  end
-  # Initialize a new liquid ThemeRunner instance
+  # Load all templates into memory, do this now so that
-  # Will load all templates into memory, do this now so that we don't profile IO.
+  # we don't profile IO.
  def initialize
-    @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
+    @tests = Dir[File.dirname(__FILE__) + '/tests/**/*.liquid'].collect do |test|
      next if File.basename(test) == 'theme.liquid'
      theme_path = File.dirname(test) + '/theme.liquid'
-      {
+
-        liquid: File.read(test),
+      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
        layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
        template_name: test,
      }
    end.compact
    compile_all_tests
  end
  # `compile` will test just the compilation portion of liquid without any templates
  def compile
-    @tests.each do |test_hash|
+    # Dup assigns because will make some changes to them
-      Liquid::Template.new.parse(test_hash[:liquid])
+
-      Liquid::Template.new.parse(test_hash[:layout])
+    @tests.each do |liquid, layout, template_name|
      tmpl = Liquid::Template.new
      tmpl.parse(liquid)
      tmpl = Liquid::Template.new
      tmpl.parse(layout)
    end
  end
  # `run` is called to benchmark rendering and compiling at the same time
   def run
    each_test do |liquid, layout, assigns, page_template, template_name|
      compile_and_render(liquid, layout, assigns, page_template, template_name)
    end
  end
  # `render` is called to benchmark just the render portion of liquid
  def render
    @compiled_tests.each do |test|
      tmpl    = test[:tmpl]
      assigns = test[:assigns]
      layout  = test[:layout]
      if layout
        assigns['content_for_layout'] = tmpl.render!(assigns)
        layout.render!(assigns)
      else
        tmpl.render!(assigns)
      end
    end
  end
  private
  def compile_and_render(template, layout, assigns, page_template, template_file)
    compiled_test                 = compile_test(template, layout, assigns, page_template, template_file)
    assigns['content_for_layout'] = compiled_test[:tmpl].render!(assigns)
    compiled_test[:layout].render!(assigns) if layout
  end
  def compile_all_tests
    @compiled_tests = []
    each_test do |liquid, layout, assigns, page_template, template_name|
      @compiled_tests << compile_test(liquid, layout, assigns, page_template, template_name)
    end
    @compiled_tests
  end
  def compile_test(template, layout, assigns, page_template, template_file)
    tmpl            = init_template(page_template, template_file)
    parsed_template = tmpl.parse(template).dup
    if layout
      parsed_layout = tmpl.parse(layout)
      { tmpl: parsed_template, assigns: assigns, layout: parsed_layout }
    else
      { tmpl: parsed_template, assigns: assigns }
    end
  end
  # utility method with similar functionality needed in `compile_all_tests` and `run`
  def each_test
    # Dup assigns because will make some changes to them
    assigns = Database.tables.dup
-    @tests.each do |test_hash|
+    @tests.each do |liquid, layout, template_name|
-      # Compute page_template outside of profiler run, uninteresting to profiler
+
-      page_template = File.basename(test_hash[:template_name], File.extname(test_hash[:template_name]))
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
-      yield(test_hash[:liquid], test_hash[:layout], assigns, page_template, test_hash[:template_name])
+      page_template = File.basename(template_name, File.extname(template_name))
      compile_and_render(liquid, layout, assigns, page_template, 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)
+  def compile_and_render(template, layout, assigns, page_template, template_file)
    tmpl = Liquid::Template.new
    tmpl.assigns['page_title'] = 'Page title'
    tmpl.assigns['template'] = page_template
    tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
-    tmpl
+
    content_for_layout = tmpl.parse(template).render!(assigns)
    if layout
      assigns['content_for_layout'] = content_for_layout
      tmpl.parse(layout).render!(assigns)
    else
      content_for_layout
    end
  end
 end
--- a/test/integration/assign_test.rb
+++ b/test/integration/assign_test.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 require 'test_helper'
 class AssignTest < Minitest::Test
@@ -12,17 +10,17 @@ class AssignTest < Minitest::Test
    END_TEMPLATE
    template = Template.parse(template_source)
    rendered = template.render!
-    assert_equal("Print this-thing", rendered.strip)
+    assert_equal "Print this-thing", rendered.strip
  end
  def test_assigned_variable
    assert_template_result('.foo.',
                           '{% assign foo = values %}.{{ foo[0] }}.',
-      'values' => %w(foo bar baz))
+                           'values' => %w{foo bar baz})
    assert_template_result('.bar.',
                           '{% assign foo = values %}.{{ foo[1] }}.',
-      'values' => %w(foo bar baz))
+                           'values' => %w{foo bar baz})
  end
  def test_assign_with_filter
--- 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)
+  def render(*args)
-    output << ' '
+    " "
    output
  end
  Liquid::Template.register_tag('foobar', FoobarTag)
 end
 class BlankTestFileSystem
@@ -32,10 +31,8 @@ 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
  end
  def test_loops_are_blank
    assert_template_result("", wrap_in_for(" "))
@@ -64,8 +61,8 @@ class BlankTest < Minitest::Test
  def test_nested_blocks_are_blank_but_only_if_all_children_are
    assert_template_result("", wrap(wrap(" ")))
    assert_template_result("\n       but this is not "*(N+1),
-      wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
+      wrap(%q{{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
-      {% if true %} but this is not {% endif %}'))
+      {% if true %} but this is not {% endif %}}))
  end
  def test_assigns_are_blank
@@ -96,9 +93,9 @@ class BlankTest < Minitest::Test
  def test_include_is_blank
    Liquid::Template.file_system = BlankTestFileSystem.new
-    assert_template_result("foobar" * (N + 1), wrap("{% include 'foobar' %}"))
+    assert_template_result "foobar"*(N+1), wrap("{% include 'foobar' %}")
-    assert_template_result(" foobar " * (N + 1), wrap("{% include ' foobar ' %}"))
+    assert_template_result " foobar "*(N+1), wrap("{% include ' foobar ' %}")
-    assert_template_result("   " * (N + 1), wrap(" {% include ' ' %} "))
+    assert_template_result "   "*(N+1), wrap(" {% include ' ' %} ")
  end
  def test_case_is_blank
--- a/test/integration/block_test.rb
+++ b/test/integration/block_test.rb
@@ -1,58 +0,0 @@
 # frozen_string_literal: true
 require 'test_helper'
 class BlockTest < Minitest::Test
  include Liquid
  def test_unexpected_end_tag
    exc = assert_raises(SyntaxError) do
      Template.parse("{% if true %}{% endunless %}")
    end
    assert_equal(exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif")
  end
  def test_with_custom_tag
    with_custom_tag('testtag', Block) do
      assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
    end
  end
  def test_custom_block_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
    klass1 = Class.new(Block) do
      def render(*)
        'hello'
      end
    end
    with_custom_tag('blabla', klass1) do
      template = Liquid::Template.parse("{% blabla %} bla {% endblabla %}")
      assert_equal 'hello', template.render
      buf    = +''
      output = template.render({}, output: buf)
      assert_equal 'hello', output
      assert_equal 'hello', buf
      assert_equal buf.object_id, output.object_id
    end
    klass2 = Class.new(klass1) do
      def render(*)
        'foo' + super + 'bar'
      end
    end
    with_custom_tag('blabla', klass2) do
      template = Liquid::Template.parse("{% blabla %} foo {% endblabla %}")
      assert_equal 'foohellobar', template.render
      buf    = +''
      output = template.render({}, output: buf)
      assert_equal 'foohellobar', output
      assert_equal 'foohellobar', buf
      assert_equal buf.object_id, output.object_id
    end
  end
 end
--- 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
@@ -16,7 +14,7 @@ class CaptureTest < Minitest::Test
    END_TEMPLATE
    template = Template.parse(template_source)
    rendered = template.render!
-    assert_equal("Print this-thing", rendered.strip)
+    assert_equal "Print this-thing", rendered.strip
  end
  def test_capture_to_variable_from_outer_scope_if_existing
@@ -32,7 +30,7 @@ class CaptureTest < Minitest::Test
    END_TEMPLATE
    template = Template.parse(template_source)
    rendered = template.render!
-    assert_equal("test-string", rendered.gsub(/\s/, ''))
+    assert_equal "test-string", rendered.gsub(/\s/, '')
  end
  def test_assigning_from_capture
@@ -47,6 +45,6 @@ class CaptureTest < Minitest::Test
    END_TEMPLATE
    template = Template.parse(template_source)
    rendered = template.render!
-    assert_equal("3-3", rendered.gsub(/\s/, ''))
+    assert_equal "3-3", rendered.gsub(/\s/, '')
  end
 end # CaptureTest
--- a/test/integration/context_test
+++ b/test/integration/context_test
@@ -1,608 +0,0 @@
 # frozen_string_literal: true
 require 'test_helper'
 class HundredCentes
  def to_liquid
    100
  end
 end
 class CentsDrop < Liquid::Drop
  def amount
    HundredCentes.new
  end
  def non_zero?
    true
  end
 end
 class ContextSensitiveDrop < Liquid::Drop
  def test
    @context['test']
  end
 end
 class Category < Liquid::Drop
  attr_accessor :name
  def initialize(name)
    @name = name
  end
  def to_liquid
    CategoryDrop.new(self)
  end
 end
 class CategoryDrop
  attr_accessor :category, :context
  def initialize(category)
    @category = category
  end
 end
 class CounterDrop < Liquid::Drop
  def count
    @count ||= 0
    @count  += 1
  end
 end
 class ArrayLike
  def fetch(index)
  end
  def [](index)
    @counts        ||= []
    @counts[index] ||= 0
    @counts[index]  += 1
  end
  def to_liquid
    self
  end
 end
 class ContextTest < Minitest::Test
  include Liquid
  def setup
    @context = Liquid::Context.new
  end
  def test_variables
    @context['string'] = 'string'
    assert_equal('string', @context['string'])
    @context['num'] = 5
    assert_equal(5, @context['num'])
    @context['time'] = Time.parse('2006-06-06 12:00:00')
    assert_equal(Time.parse('2006-06-06 12:00:00'), @context['time'])
    @context['date'] = Date.today
    assert_equal(Date.today, @context['date'])
    now = Time.now
    @context['datetime'] = now
    assert_equal(now, @context['datetime'])
    @context['bool'] = true
    assert_equal(true, @context['bool'])
    @context['bool'] = false
    assert_equal(false, @context['bool'])
    @context['nil'] = nil
    assert_nil(@context['nil'])
    assert_nil(@context['nil'])
  end
  def test_variables_not_existing
    assert_nil(@context['does_not_exist'])
  end
  def test_scoping
    @context.push
    @context.pop
    assert_raises(Liquid::ContextError) do
      @context.pop
    end
    assert_raises(Liquid::ContextError) do
      @context.push
      @context.pop
      @context.pop
    end
  end
  def test_length_query
    @context['numbers'] = [1, 2, 3, 4]
    assert_equal(4, @context['numbers.size'])
    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
    assert_equal(4, @context['numbers.size'])
    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
    assert_equal(1000, @context['numbers.size'])
  end
  def test_hyphenated_variable
    @context['oh-my'] = 'godz'
    assert_equal('godz', @context['oh-my'])
  end
  def test_add_filter
    filter = Module.new do
      def hi(output)
        output + ' hi!'
      end
    end
    context = Context.new
    context.add_filters(filter)
    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
    context = Context.new
    assert_equal('hi?', context.invoke(:hi, 'hi?'))
    context.add_filters(filter)
    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
  end
  def test_only_intended_filters_make_it_there
    filter = Module.new do
      def hi(output)
        output + ' hi!'
      end
    end
    context = Context.new
    assert_equal("Wookie", context.invoke("hi", "Wookie"))
    context.add_filters(filter)
    assert_equal("Wookie hi!", context.invoke("hi", "Wookie"))
  end
  def test_add_item_in_outer_scope
    @context['test'] = 'test'
    @context.push
    assert_equal('test', @context['test'])
    @context.pop
    assert_equal('test', @context['test'])
  end
  def test_add_item_in_inner_scope
    @context.push
    @context['test'] = 'test'
    assert_equal('test', @context['test'])
    @context.pop
    assert_nil(@context['test'])
  end
  def test_hierachical_data
    @context['hash'] = { "name" => 'tobi' }
    assert_equal('tobi', @context['hash.name'])
    assert_equal('tobi', @context['hash["name"]'])
  end
  def test_keywords
    assert_equal(true, @context['true'])
    assert_equal(false, @context['false'])
  end
  def test_digits
    assert_equal(100, @context['100'])
    assert_equal(100.00, @context['100.00'])
  end
  def test_strings
    assert_equal("hello!", @context['"hello!"'])
    assert_equal("hello!", @context["'hello!'"])
  end
  def test_merge
    @context.merge("test" => "test")
    assert_equal('test', @context['test'])
    @context.merge("test" => "newvalue", "foo" => "bar")
    assert_equal('newvalue', @context['test'])
    assert_equal('bar', @context['foo'])
  end
  def test_array_notation
    @context['test'] = [1, 2, 3, 4, 5]
    assert_equal(1, @context['test[0]'])
    assert_equal(2, @context['test[1]'])
    assert_equal(3, @context['test[2]'])
    assert_equal(4, @context['test[3]'])
    assert_equal(5, @context['test[4]'])
  end
  def test_recoursive_array_notation
    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
    assert_equal(1, @context['test.test[0]'])
    @context['test'] = [{ 'test' => 'worked' }]
    assert_equal('worked', @context['test[0].test'])
  end
  def test_hash_to_array_transition
    @context['colors'] = {
      'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
      'Green' => ['003300', '336633', '669966', '99CC99'],
      'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
      'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
    }
    assert_equal('003366', @context['colors.Blue[0]'])
    assert_equal('FF9999', @context['colors.Red[3]'])
  end
  def test_try_first
    @context['test'] = [1, 2, 3, 4, 5]
    assert_equal(1, @context['test.first'])
    assert_equal(5, @context['test.last'])
    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
    assert_equal(1, @context['test.test.first'])
    assert_equal(5, @context['test.test.last'])
    @context['test'] = [1]
    assert_equal(1, @context['test.first'])
    assert_equal(1, @context['test.last'])
  end
  def test_access_hashes_with_hash_notation
    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
    @context['product']  = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
    assert_equal(5, @context['products["count"]'])
    assert_equal('deepsnow', @context['products["tags"][0]'])
    assert_equal('deepsnow', @context['products["tags"].first'])
    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
    assert_equal('element151cm', @context['product["variants"][1]["title"]'])
    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
    assert_equal('element151cm', @context['product["variants"].last["title"]'])
  end
  def test_access_variable_with_hash_notation
    @context['foo'] = 'baz'
    @context['bar'] = 'foo'
    assert_equal('baz', @context['["foo"]'])
    assert_equal('baz', @context['[bar]'])
  end
  def test_access_hashes_with_hash_access_variables
    @context['var']      = 'tags'
    @context['nested']   = { 'var' => 'tags' }
    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
    assert_equal('deepsnow', @context['products[var].first'])
    assert_equal('freestyle', @context['products[nested.var].last'])
  end
  def test_hash_notation_only_for_hash_access
    @context['array'] = [1, 2, 3, 4, 5]
    @context['hash']  = { 'first' => 'Hello' }
    assert_equal(1, @context['array.first'])
    assert_nil(@context['array["first"]'])
    assert_equal('Hello', @context['hash["first"]'])
  end
  def test_first_can_appear_in_middle_of_callchain
    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
    assert_equal('draft151cm', @context['product.variants[0].title'])
    assert_equal('element151cm', @context['product.variants[1].title'])
    assert_equal('draft151cm', @context['product.variants.first.title'])
    assert_equal('element151cm', @context['product.variants.last.title'])
  end
  def test_cents
    @context.merge("cents" => HundredCentes.new)
    assert_equal(100, @context['cents'])
  end
  def test_nested_cents
    @context.merge("cents" => { 'amount' => HundredCentes.new })
    assert_equal(100, @context['cents.amount'])
    @context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
    assert_equal(100, @context['cents.cents.amount'])
  end
  def test_cents_through_drop
    @context.merge("cents" => CentsDrop.new)
    assert_equal(100, @context['cents.amount'])
  end
  def test_nested_cents_through_drop
    @context.merge("vars" => { "cents" => CentsDrop.new })
    assert_equal(100, @context['vars.cents.amount'])
  end
  def test_drop_methods_with_question_marks
    @context.merge("cents" => CentsDrop.new)
    assert(@context['cents.non_zero?'])
  end
  def test_context_from_within_drop
    @context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
    assert_equal('123', @context['vars.test'])
  end
  def test_nested_context_from_within_drop
    @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
    assert_equal('123', @context['vars.local.test'])
  end
  def test_ranges
    @context.merge("test" => '5')
    assert_equal((1..5), @context['(1..5)'])
    assert_equal((1..5), @context['(1..test)'])
    assert_equal((5..5), @context['(test..test)'])
  end
  def test_cents_through_drop_nestedly
    @context.merge("cents" => { "cents" => CentsDrop.new })
    assert_equal(100, @context['cents.cents.amount'])
    @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
    assert_equal(100, @context['cents.cents.cents.amount'])
  end
  def test_drop_with_variable_called_only_once
    @context['counter'] = CounterDrop.new
    assert_equal(1, @context['counter.count'])
    assert_equal(2, @context['counter.count'])
    assert_equal(3, @context['counter.count'])
  end
  def test_drop_with_key_called_only_once
    @context['counter'] = CounterDrop.new
    assert_equal(1, @context['counter["count"]'])
    assert_equal(2, @context['counter["count"]'])
    assert_equal(3, @context['counter["count"]'])
  end
  def test_proc_as_variable
    @context['dynamic'] = proc { 'Hello' }
    assert_equal('Hello', @context['dynamic'])
  end
  def test_lambda_as_variable
    @context['dynamic'] = proc { 'Hello' }
    assert_equal('Hello', @context['dynamic'])
  end
  def test_nested_lambda_as_variable
    @context['dynamic'] = { "lambda" => proc { 'Hello' } }
    assert_equal('Hello', @context['dynamic.lambda'])
  end
  def test_array_containing_lambda_as_variable
    @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
    assert_equal('Hello', @context['dynamic[2]'])
  end
  def test_lambda_is_called_once
    @context['callcount'] = proc {
      @global ||= 0
      @global  += 1
      @global.to_s
    }
    assert_equal('1', @context['callcount'])
    assert_equal('1', @context['callcount'])
    assert_equal('1', @context['callcount'])
    @global = nil
  end
  def test_nested_lambda_is_called_once
    @context['callcount'] = { "lambda" => proc {
                                            @global ||= 0
                                            @global  += 1
                                            @global.to_s
                                          } }
    assert_equal('1', @context['callcount.lambda'])
    assert_equal('1', @context['callcount.lambda'])
    assert_equal('1', @context['callcount.lambda'])
    @global = nil
  end
  def test_lambda_in_array_is_called_once
    @context['callcount'] = [1, 2, proc {
                                     @global ||= 0
                                     @global  += 1
                                     @global.to_s
                                   }, 4, 5]
    assert_equal('1', @context['callcount[2]'])
    assert_equal('1', @context['callcount[2]'])
    assert_equal('1', @context['callcount[2]'])
    @global = nil
  end
  def test_access_to_context_from_proc
    @context.registers[:magic] = 345392
    @context['magic'] = proc { @context.registers[:magic] }
    assert_equal(345392, @context['magic'])
  end
  def test_to_liquid_and_context_at_first_level
    @context['category'] = Category.new("foobar")
    assert_kind_of(CategoryDrop, @context['category'])
    assert_equal(@context, @context['category'].context)
  end
  def test_interrupt_avoids_object_allocations
    assert_no_object_allocations do
      @context.interrupt?
    end
  end
  def test_context_initialization_with_a_proc_in_environment
    contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo)
    assert(contx)
    assert_nil(contx['poutine'])
  end
  def test_apply_global_filter
    global_filter_proc = ->(output) { "#{output} filtered" }
    context = Context.new
    context.global_filter = global_filter_proc
    assert_equal('hi filtered', context.apply_global_filter('hi'))
  end
  def test_static_environments_are_read_with_lower_priority_than_environments
    context = Context.build(
      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
      environments: { 'shadowed' => 'dynamic' }
    )
    assert_equal('dynamic', context['shadowed'])
    assert_equal('static', context['unshadowed'])
  end
  def test_apply_global_filter_when_no_global_filter_exist
    context = Context.new
    assert_equal('hi', context.apply_global_filter('hi'))
  end
  def test_new_isolated_subcontext_does_not_inherit_variables
    super_context = Context.new
    super_context['my_variable'] = 'some value'
    subcontext = super_context.new_isolated_subcontext
    assert_nil(subcontext['my_variable'])
  end
  def test_new_isolated_subcontext_inherits_static_environment
    super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
    subcontext    = super_context.new_isolated_subcontext
    assert_equal('my value', subcontext['my_environment_value'])
  end
  def test_new_isolated_subcontext_inherits_resource_limits
    resource_limits = ResourceLimits.new({})
    super_context   = Context.new({}, {}, {}, false, resource_limits)
    subcontext      = super_context.new_isolated_subcontext
    assert_equal(resource_limits, subcontext.resource_limits)
  end
  def test_new_isolated_subcontext_inherits_exception_renderer
    super_context = Context.new
    super_context.exception_renderer = ->(_e) { 'my exception message' }
    subcontext = super_context.new_isolated_subcontext
    assert_equal('my exception message', subcontext.handle_error(Liquid::Error.new))
  end
  def test_new_isolated_subcontext_does_not_inherit_non_static_registers
    registers = {
      my_register: :my_value,
    }
    super_context = Context.new({}, {}, StaticRegisters.new(registers))
    super_context.registers[:my_register] = :my_alt_value
    subcontext                            = super_context.new_isolated_subcontext
    assert_equal(:my_value, subcontext.registers[:my_register])
  end
  def test_new_isolated_subcontext_inherits_static_registers
    super_context = Context.build(registers: { my_register: :my_value })
    subcontext    = super_context.new_isolated_subcontext
    assert_equal(:my_value, subcontext.registers[:my_register])
  end
  def test_new_isolated_subcontext_registers_do_not_pollute_context
    super_context                      = Context.build(registers: { my_register: :my_value })
    subcontext                         = super_context.new_isolated_subcontext
    subcontext.registers[:my_register] = :my_alt_value
    assert_equal(:my_value, super_context.registers[:my_register])
  end
  def test_new_isolated_subcontext_inherits_filters
    my_filter = Module.new do
      def my_filter(*)
        'my filter result'
      end
    end
    super_context = Context.new
    super_context.add_filters([my_filter])
    subcontext    = super_context.new_isolated_subcontext
    template      = Template.parse('{{ 123 | my_filter }}')
    assert_equal('my filter result', template.render(subcontext))
  end
  def test_disables_tag_specified
    context = Context.new
    context.with_disabled_tags(%w(foo bar)) do
      assert_equal true, context.tag_disabled?("foo")
      assert_equal true, context.tag_disabled?("bar")
      assert_equal false, context.tag_disabled?("unknown")
    end
  end
  def test_disables_nested_tags
    context = Context.new
    context.with_disabled_tags(["foo"]) do
      context.with_disabled_tags(["foo"]) do
        assert_equal true, context.tag_disabled?("foo")
        assert_equal false, context.tag_disabled?("bar")
      end
      context.with_disabled_tags(["bar"]) do
        assert_equal true, context.tag_disabled?("foo")
        assert_equal true, context.tag_disabled?("bar")
        context.with_disabled_tags(["foo"]) do
          assert_equal true, context.tag_disabled?("foo")
          assert_equal true, context.tag_disabled?("bar")
        end
      end
      assert_equal true, context.tag_disabled?("foo")
      assert_equal false, context.tag_disabled?("bar")
    end
  end
  private
  def assert_no_object_allocations
    unless RUBY_ENGINE == 'ruby'
      skip("stackprof needed to count object allocations")
    end
    require 'stackprof'
    profile = StackProf.run(mode: :object) do
      yield
    end
    assert_equal(0, profile[:samples])
  end
 end # ContextTest
--- a/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
@@ -20,14 +18,14 @@ class ContextTest < Minitest::Test
    with_global_filter(global) do
      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, filters: [local])
+      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
    end
  end
  def test_has_key_will_not_add_an_error_for_missing_keys
    with_error_mode :strict do
      context = Context.new
-      context.key?('unknown')
+      context.has_key?('unknown')
      assert_empty context.errors
    end
  end
--- 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/Show More
+++ b/Show More
Author	SHA1	Message	Date
Lourens Naudé	e853bf5b84	Also dump object distribution	2015-05-06 10:45:20 -04:00
Lourens Naudé	27248f1eb1	Lazy init context errors and interrupts to prevent excess allocation	2015-05-05 23:40:52 -04:00
Lourens Naudé	174839fbef	Reuse filters array during variable parsing	2015-05-05 23:30:05 -04:00
Lourens Naudé	01a86728f2	Remove needless intermediate local var in VariableLookup#initialize	2015-05-05 23:21:28 -04:00
Lourens Naudé	0e38f88b58	Recycle the array buffer in BlockBody#render	2015-05-05 23:02:08 -04:00
Lourens Naudé	5a48edae6a	Introduce support for memory usage profiles	2015-05-05 23:00:28 -04:00