Add test for spaces in square brackets

2026-01-02 00:05:42 +03:00 · 2014-10-22 15:47:12 -04:00
135 changed files with 2281 additions and 6874 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,16 +0,0 @@
-inherit_from:
-  - https://shopify.github.io/ruby-style-guide/rubocop.yml
-  - .rubocop_todo.yml
-
-require: rubocop-performance
-
-Performance:
-  Enabled: true
-
-AllCops:
-  Exclude:
-    - 'vendor/bundle/**/*'
-      
-Naming/MethodName:
-  Exclude:
-    - 'example/server/liquid_servlet.rb'
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -1,101 +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
-Lint/AmbiguousOperator:
-  Exclude:
-    - 'test/unit/condition_unit_test.rb'
-
-# Offense count: 21
-# Configuration parameters: AllowSafeAssignment.
-Lint/AssignmentInCondition:
-  Exclude:
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/lexer.rb'
-    - 'lib/liquid/standardfilters.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/tags/raw.rb'
-    - 'lib/liquid/variable.rb'
-    - 'performance/profile.rb'
-    - 'test/test_helper.rb'
-    - 'test/unit/tokenizer_unit_test.rb'
-
-# Offense count: 2
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: runtime_error, standard_error
-Lint/InheritException:
-  Exclude:
-    - 'lib/liquid/interrupts.rb'
-
-# Offense count: 2
-Lint/UselessAssignment:
-  Exclude:
-    - 'performance/shopify/database.rb'
-
-# Offense count: 1
-# Configuration parameters: CheckForMethodsWithNoSideEffects.
-Lint/Void:
-  Exclude:
-    - 'lib/liquid/parse_context.rb'
-
-# Offense count: 98
-# Cop supports --auto-correct.
-# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
-# URISchemes: http, https
-Metrics/LineLength:
-  Max: 294
-
-# Offense count: 44
-Naming/ConstantName:
-  Exclude:
-    - 'lib/liquid.rb'
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/tags/assign.rb'
-    - 'lib/liquid/tags/capture.rb'
-    - 'lib/liquid/tags/case.rb'
-    - 'lib/liquid/tags/cycle.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/tags/include.rb'
-    - 'lib/liquid/tags/raw.rb'
-    - 'lib/liquid/tags/table_row.rb'
-    - 'lib/liquid/variable.rb'
-    - 'performance/shopify/comment_form.rb'
-    - 'performance/shopify/paginate.rb'
-    - 'test/integration/tags/include_tag_test.rb'
-
-# Offense count: 5
-Style/ClassVars:
-  Exclude:
-    - 'lib/liquid/condition.rb'
-    - 'lib/liquid/strainer.rb'
-    - 'lib/liquid/template.rb'
-
-# Offense count: 1
-# Configuration parameters: AllowCoercion.
-Style/DateTime:
-  Exclude:
-    - 'test/unit/context_unit_test.rb'
-
-# Offense count: 119
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: always, never
-Style/FrozenStringLiteralComment:
-  Enabled: false
-
-# Offense count: 9
-# Cop supports --auto-correct.
-# Configuration parameters: AllowAsExpressionSeparator.
-Style/Semicolon:
-  Exclude:
-    - 'test/integration/error_handling_test.rb'
-    - 'test/integration/template_test.rb'
-    - 'test/unit/context_unit_test.rb'
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,30 +1,16 @@
-language: ruby
-cache: bundler
-
 rvm:
-  - 2.4
-  - 2.5
-  - &latest_ruby 2.6
-  - 2.7
-  - ruby-head
+  - 1.9
+  - 2.0
+  - 2.1
+  - jruby-19mode
  - jruby-head
-  - truffleruby
-
+  - rbx-2
 matrix:
-  include:
-    - rvm: *latest_ruby
-      script: bundle exec rake memory_profile:run
-      name: Profiling Memory Usage
  allow_failures:
-    - rvm: ruby-head
+    - rvm: rbx-2
    - rvm: jruby-head
-    - rvm: truffleruby

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

 notifications:
  disable: true
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,22 +4,23 @@

 * Bugfixes
 * Performance improvements
-* Features that are likely to be useful to the majority of Liquid users
+* Features which are likely to be useful to the majority of Liquid users

 ## Things we won't merge

-* Code that introduces considerable performance degrations
-* Code that touches performance-critical parts of Liquid and comes without benchmarks
-* Features that are not important for most people (we want to keep the core Liquid code small and tidy)
-* Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
-* Code that does not include tests
-* Code that breaks existing tests
+* Code which introduces considerable performance degrations
+* Code which touches performance critical parts of Liquid and comes without benchmarks
+* Features which are not important for most people (we want to keep the core Liquid code small and tidy)
+* Features which can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
+* Code which comes without tests
+* Code which breaks existing tests

 ## Workflow

 * Fork the Liquid repository
 * Create a new branch in your fork
-* If it makes sense, add tests for your code and/or run a performance benchmark
-* Make sure all tests pass (`bundle exec rake`)
+* If it makes sense, add tests for your code and run a performance benchmark
+* Make sure all tests pass
 * Create a pull request
+* In the description, ping one of [@boourns](https://github.com/boourns), [@fw42](https://github.com/fw42), [@camilo](https://github.com/camilo), [@dylanahsmith](https://github.com/dylanahsmith), or [@arthurnn](https://github.com/arthurnn) and ask for a code review.

--- a/22
+++ b/22
@@ -1,25 +1,9 @@
 source 'https://rubygems.org'
-git_source(:github) do |repo_name|
-  "https://github.com/#{repo_name}.git"
-end

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

 group :test do
-  gem 'rubocop', '~> 0.74.0', require: false
-  gem 'rubocop-performance', require: false
-
-  platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'liquid-tag'
-  end
+  gem 'spy', '0.4.1'
+  gem 'benchmark-ips'
 end
--- a/History.md
+++ b/History.md
@@ -1,170 +1,46 @@
-# Liquid Change Log
+# Liquid Version History

-## 4.0.3 / 2019-03-12
+## 3.0.0 / not yet released / branch "master"

-### Fixed
-* Fix break and continue tags inside included templates in loops (#1072) [Justin Li]
+* ...
+* 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, see #423 [Bogdan Gusiev]
+* Add url_encode to standard filters, see #421 [Derrick Reimer, djreimer]
+* Add uniq to standard filters [Florian Weingarten, fw42]
+* Add exception_handler feature, see #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, jasonhl]
+* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
+* Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
+* Fix broken rendering of variables which are equal to false, see #345 [Florian Weingarten, fw42]
+* Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
+* Freeze lots of string literals for new Ruby 2.1 optimization, see #297 [Florian Weingarten, fw42]
+* Allow newlines in tags and variables, see #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, dylanahsmith]
+* 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, see #306 [Adam Doeler, releod]
+* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
+* Make if, for & case tags return complete and consistent nodelists, see #250 [Nick Jones, dntj]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Fix resource counting bug with respond_to?(:length), see #263 [Florian Weingarten, fw42]
+* Allow specifying custom patterns for template filenames, see #284 [Andrei Gladkyi, agladkyi]
+* Allow drops to optimize loading a slice of elements, see #282 [Tom Burns, boourns]
+* Support for passing variables to snippets in subdirs, see #271 [Joost Hietbrink, joost]
+* Add a class cache to avoid runtime extend calls, see #249 [James Tucker, raggi]
+* Remove some legacy Ruby 1.8 compatibility code, see #276 [Florian Weingarten, fw42]
+* Add default filter to standard filters, see #267 [Derrick Reimer, djreimer]
+* Add optional strict parsing and warn parsing, see #235 [Tristan Hume, trishume]
+* Add I18n syntax error translation, see #241 [Simon Hørup Eskildsen, Sirupsen]
+* Make sort filter work on enumerable drops, see #239 [Florian Weingarten, fw42]
+* Fix clashing method names in enumerable drops, see #238 [Florian Weingarten, fw42]
+* Make map filter work on enumerable drops, see #233 [Florian Weingarten, fw42]
+* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]

-## 4.0.2 / 2019-03-08
-
-### Changed
-* Add `where` filter (#1026) [Samuel Doiron]
-* Add `ParseTreeVisitor` to iterate the Liquid AST (#1025) [Stephen Paul Weber]
-* Improve `strip_html` performance (#1032) [printercu]
-
-### Fixed
-* Add error checking for invalid combinations of inputs to sort, sort_natural, where, uniq, map, compact filters (#1059) [Garland Zhang]
-* Validate the character encoding in url_decode (#1070) [Clayton Smith]
-
-## 4.0.1 / 2018-10-09
-
-### Changed
-* Add benchmark group in Gemfile (#855) [Jerry Liu]
-* Allow benchmarks to benchmark render by itself (#851) [Jerry Liu]
-* Avoid calling `line_number` on String node when rescuing a render error. (#860) [Dylan Thacker-Smith]
-* Avoid duck typing to detect whether to call render on a node. [Dylan Thacker-Smith]
-* Clarify spelling of `reversed` on `for` block tag (#843) [Mark Crossfield]
-* Replace recursion with loop to avoid potential stack overflow from malicious input (#891, #892) [Dylan Thacker-Smith]
-* Limit block tag nesting to 100 (#894) [Dylan Thacker-Smith]
-* Replace `assert_equal nil` with `assert_nil` (#895) [Dylan Thacker-Smith]
-* Remove Spy Gem (#896) [Dylan Thacker-Smith]
-* Add `collection_name` and `variable_name` reader to `For` block (#909)
-* Symbols render as strings (#920) [Justin Li]
-* Remove default value from Hash objects (#932) [Maxime Bedard]
-* Remove one level of nesting (#944) [Dylan Thacker-Smith]
-* Update Rubocop version (#952) [Justin Li]
-* Add `at_least` and `at_most` filters (#954, #958) [Nithin Bekal]
-* Add a regression test for a liquid-c trim mode bug (#972) [Dylan Thacker-Smith]
-* Use https rather than git protocol to fetch liquid-c [Dylan Thacker-Smith]
-* Add tests against Ruby 2.4 (#963) and 2.5 (#981)
-* Replace RegExp literals with constants (#988) [Ashwin Maroli]
-* Replace unnecessary `#each_with_index` with `#each` (#992) [Ashwin Maroli]
-* Improve the unexpected end delimiter message for block tags. (#1003) [Dylan Thacker-Smith]
-* Refactor and optimize rendering (#1005) [Christopher Aue]
-* Add installation instruction (#1006) [Ben Gift]
-* Remove Circle CI (#1010)
-* Rename deprecated `BigDecimal.new` to `BigDecimal` (#1024) [Koichi ITO]
-* Rename deprecated Rubocop name (#1027) [Justin Li]
-
-### Fixed
-* Handle `join` filter on non String joiners (#857) [Richard Monette]
-* Fix duplicate inclusion condition logic error of `Liquid::Strainer.add_filter` method (#861)
-* Fix `escape`, `url_encode`, `url_decode` not handling non-string values (#898) [Thierry Joyal]
-* Fix raise when variable is defined but nil when using `strict_variables` [Pascal Betz]
-* Fix `sort` and `sort_natural` to handle arrays with nils (#930) [Eric Chan]
-
-## 4.0.0 / 2016-12-14 / branch "4-0-stable"
-
-### Changed
-* Render an opaque internal error by default for non-Liquid::Error (#835) [Dylan Thacker-Smith]
-* Ruby 2.0 support dropped (#832) [Dylan Thacker-Smith]
-* Add to_number Drop method to allow custom drops to work with number filters (#731)
-* Add strict_variables and strict_filters options to detect undefined references (#691)
-* Improve loop performance (#681) [Florian Weingarten]
-* Rename Drop method `before_method` to `liquid_method_missing` (#661) [Thierry Joyal]
-* Add url_decode filter to invert url_encode (#645) [Larry Archer]
-* 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
-
-* Remove duplicate `index0` key in TableRow tag (#502) [Alfred Xing]
-
-## 3.0.0 / 2014-11-12
-
-* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith]
-* Fixed condition with wrong data types (#423) [Bogdan Gusiev]
-* Add url_encode to standard filters (#421) [Derrick Reimer]
-* Add uniq to standard filters [Florian Weingarten]
-* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, Florian Weingarten]
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge]
-* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge]
-* Properly set context rethrow_errors on render! #349 [Thierry Joyal]
-* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten]
-* Remove ActionView template handler [Dylan Thacker-Smith]
-* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten]
-* Allow newlines in tags and variables (#324) [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]
-* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev]
-* Add a to_s default for liquid drops (#306) [Adam Doeler]
-* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten]
-* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
-* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten]
-* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi]
-* Allow drops to optimize loading a slice of elements (#282) [Tom Burns]
-* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink]
-* Add a class cache to avoid runtime extend calls (#249) [James Tucker]
-* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten]
-* Add default filter to standard filters (#267) [Derrick Reimer]
-* Add optional strict parsing and warn parsing (#235) [Tristan Hume]
-* Add I18n syntax error translation (#241) [Simon Hørup Eskildsen, Sirupsen]
-* Make sort filter work on enumerable drops (#239) [Florian Weingarten]
-* Fix clashing method names in enumerable drops (#238) [Florian Weingarten]
-* Make map filter work on enumerable drops (#233) [Florian Weingarten]
-* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten]
-
-## 2.6.3 / 2015-07-23 / branch "2-6-stable"
-
-* Fix test failure under certain timezones [Dylan Thacker-Smith]
-
-## 2.6.2 / 2015-01-23
-
-* Remove duplicate hash key [Parker Moore]
-
-## 2.6.1 / 2014-01-10
+## 2.6.1 / 2014-01-10 / branch "2-6-stable"

 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]

 ## 2.6.0 / 2013-11-25

@@ -172,37 +48,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 #114: strip_html filter supports style tags [James Allardice]
-* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup]
-* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten]
-* Bugfix for #204: 'raw' parsing bug [Florian Weingarten]
-* Bugfix for #150: 'for' parsing bug [Peter Schröder]
-* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder]
-* Bugfix for #174, "can't convert Fixnum into String" for "replace" [jsw0528]
-* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep]
-* Resource limits [Florian Weingarten]
-* Add reverse filter [Jay Strybis]
+* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
+* 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, ndwebgroup]
+* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten, fw42]
+* Bugfix for #204: 'raw' parsing bug [Florian Weingarten, fw42]
+* Bugfix for #150: 'for' parsing bug [Peter Schröder, phoet]
+* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder, phoet]
+* 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, darkhelmet]
+* Resource limits [Florian Weingarten, fw42]
+* Add reverse filter [Jay Strybis, unreal]
 * Add utf-8 support
-* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos]
-* Cache tokenized partial templates [Tom Burns]
-* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer]
-* Better documentation for 'include' tag (closes #163) [Peter Schröder]
-* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves]
+* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos, astathopoulos]
+* Cache tokenized partial templates [Tom Burns, boourns]
+* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer, stomar]
+* 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, 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]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
+* Prevent arbitrary method invocation on condition objects, see #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", see #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

@@ -210,7 +86,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
@@ -1,5 +1,5 @@
-[![Build Status](https://api.travis-ci.org/Shopify/liquid.svg?branch=master)](http://travis-ci.org/Shopify/liquid)
-[![Inline docs](http://inch-ci.org/github/Shopify/liquid.svg?branch=master)](http://inch-ci.org/github/Shopify/liquid)
+[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png?branch=master)](http://travis-ci.org/Shopify/liquid)
+[![Inline docs](http://inch-ci.org/github/Shopify/liquid.png)](http://inch-ci.org/github/Shopify/liquid)

 # Liquid template engine

@@ -42,8 +42,6 @@ Liquid is a template engine which was written with very specific requirements:

 ## How to use Liquid

-Install Liquid by adding `gem 'liquid'` to your gemfile.
-
 Liquid supports a very simple API based around the Liquid::Template class.
 For standard use you can just pass it the content of a file and call render with a parameters hash.

@@ -75,34 +73,3 @@ This is useful for doing things like enabling strict mode only in the theme edit

 It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
 It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
-
-### Undefined variables and filters
-
-By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.
-You can improve this situation by passing `strict_variables: true` and/or `strict_filters: true` options to the `render` method.
-When one of these options is set to true, all errors about undefined variables and undefined filters will be stored in `errors` array of a `Liquid::Template` instance.
-Here are some examples:
-
-```ruby
-template = Liquid::Template.parse("{{x}} {{y}} {{z.a}} {{z.b}}")
-template.render({ 'x' => 1, 'z' => { 'a' => 2 } }, { strict_variables: true })
-#=> '1  2 ' # when a variable is undefined, it's rendered as nil
-template.errors
-#=> [#<Liquid::UndefinedVariable: Liquid error: undefined variable y>, #<Liquid::UndefinedVariable: Liquid error: undefined variable b>]
-```
-
-```ruby
-template = Liquid::Template.parse("{{x | filter1 | upcase}}")
-template.render({ 'x' => 'foo' }, { strict_filters: true })
-#=> '' # when at least one filter in the filter chain is undefined, a whole expression is rendered as nil
-template.errors
-#=> [#<Liquid::UndefinedFilter: Liquid error: undefined filter filter1>]
-```
-
-If you want to raise on a first exception instead of pushing all of them in `errors`, you can use `render!` method:
-
-```ruby
-template = Liquid::Template.parse("{{x}} {{y}}")
-template.render!({ 'x' => 1}, { strict_variables: true })
-#=> Liquid::UndefinedVariable: Liquid error: undefined variable y
-```
--- a/53
+++ b/53
@@ -1,62 +1,42 @@
 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
-  if RUBY_ENGINE == 'ruby'
-    require 'rubocop/rake_task'
-    RuboCop::RakeTask.new
-  end
-end
-
-desc('runs test suite with both strict and lax parsers')
+desc 'runs test suite with both strict and lax parsers'
 task :test do
  ENV['LIQUID_PARSER_MODE'] = 'lax'
  Rake::Task['base_test'].invoke
-
  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"
@@ -64,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"
@@ -75,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"
@@ -85,20 +68,10 @@ namespace :profile do
  task :strict do
    ruby "./performance/profile.rb strict"
  end
+
 end

-namespace :memory_profile do
-  desc "Run memory profiler"
-  task :run do
-    ruby "./performance/memory_profile.rb"
-  end
-end
-
-desc("Run example")
+desc "Run example"
 task :example do
  ruby "-w -d -Ilib example/server/server.rb"
 end
-
-task :console do
-  exec 'irb -I lib -r liquid'
-end
--- a/example/server/example_servlet.rb
+++ b/example/server/example_servlet.rb
@@ -1,10 +1,10 @@
 module ProductsFilter
  def price(integer)
-    format("$%.2d USD", integer / 100.0)
+    sprintf("$%.2d USD", integer / 100.0)
  end

  def prettyprint(text)
-    text.gsub(/\*(.*)\*/, '<b>\1</b>')
+    text.gsub( /\*(.*)\*/, '<b>\1</b>' )
  end

  def count(array)
@@ -17,28 +17,25 @@ module ProductsFilter
 end

 class Servlet < LiquidServlet
+
  def index
    { 'date' => Time.now }
  end

  def products
-    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true }
+    { 'products' => products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
  end

  private

  def products_list
-    [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
-     { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
-     { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
-  end
-
-  def more_products_list
-    [{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-     { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
+    [{'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+    {'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling'},
+    {'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
  end

  def 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,4 +1,5 @@
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
+
  def do_GET(req, res)
    handle(:get, req, res)
  end
@@ -9,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,12 +1,14 @@
 require 'webrick'
 require 'rexml/document'

-require_relative '../../lib/liquid'
-require_relative 'liquid_servlet'
-require_relative 'example_servlet'
+DIR = File.expand_path(File.dirname(__FILE__))
+
+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 }
+trap("INT"){ server.shutdown }
 server.start
--- a/example/server/templates/products.liquid
+++ b/example/server/templates/products.liquid
@@ -16,12 +16,12 @@
  </head>

  <body>
-    {% assign all_products = products | concat: more_products  %}
+
    <h1>{{ description | split: '~' | first }}</h1>

    <h2>{{ description | split: '~' | last }}</h2>

-    <h2>There are currently {{all_products | count}} products in the {{section}} catalog</h2>
+    <h2>There are currently {{products | count}} products in the {{section}} catalog</h2>

    {% if cool_products %}
      Cool products :)
@@ -31,7 +31,7 @@

    <ul id="products">

-      {% for product in all_products %}
+      {% for product in products %}
        <li>
          <h2>{{product.name}}</h2>
          Only {{product.price | price }}
--- a/lib/liquid.rb
+++ b/lib/liquid.rb
@@ -24,7 +24,6 @@ module Liquid
  ArgumentSeparator           = ','.freeze
  FilterArgumentSeparator     = ':'.freeze
  VariableAttributeSeparator  = '.'.freeze
-  WhitespaceControl           = '-'.freeze
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -35,7 +34,7 @@ module Liquid
  QuotedString                = /"[^"]*"|'[^']*'/
  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
+  AnyStartingTag              = /\{\{|\{\%/
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
@@ -45,13 +44,10 @@ 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'
@@ -61,21 +57,21 @@ require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
 require 'liquid/block'
-require 'liquid/block_body'
 require 'liquid/document'
 require 'liquid/variable'
 require 'liquid/variable_lookup'
 require 'liquid/range_lookup'
 require 'liquid/file_system'
-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/parse_context'
-require 'liquid/partial_cache'
+require 'liquid/token'

 # 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 }
+
+require 'liquid/profiler'
+require 'liquid/profiler/hooks'
--- a/lib/liquid/block.rb
+++ b/lib/liquid/block.rb
@@ -1,42 +1,90 @@
 module Liquid
  class Block < Tag
-    MAX_DEPTH = 100
-
-    def initialize(tag_name, markup, options)
-      super
-      @blank = true
-    end
-
-    def parse(tokens)
-      @body = BlockBody.new
-      while parse_body(@body, tokens)
-      end
-    end
-
-    # For backwards compatibility
-    def render(context)
-      @body.render(context)
-    end
+    FullToken         = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
+    TAGSTART = "{%".freeze
+    VARSTART = "{{".freeze

    def blank?
      @blank
    end

-    def nodelist
-      @body.nodelist
+    def parse(tokens)
+      @blank = true
+      @nodelist ||= []
+      @nodelist.clear
+
+      while token = tokens.shift
+        begin
+          unless token.empty?
+            case
+            when token.start_with?(TAGSTART)
+              if token =~ FullToken
+
+                # if we found the proper block delimiter just end parsing here and let the outer block
+                # proceed
+                return if block_delimiter == $1
+
+                # fetch the tag from registered blocks
+                if tag = Template.tags[$1]
+                  markup = token.is_a?(Token) ? token.child($2) : $2
+                  new_tag = tag.parse($1, markup, tokens, @options)
+                  new_tag.line_number = token.line_number if token.is_a?(Token)
+                  @blank &&= new_tag.blank?
+                  @nodelist << new_tag
+                else
+                  # this tag is not registered with the system
+                  # pass it to the current block for special handling or error reporting
+                  unknown_tag($1, $2, tokens)
+                end
+              else
+                raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
+              end
+            when token.start_with?(VARSTART)
+              new_var = create_variable(token)
+              new_var.line_number = token.line_number if token.is_a?(Token)
+              @nodelist << new_var
+              @blank = false
+            else
+              @nodelist << token
+              @blank &&= (token =~ /\A\s*\z/)
+            end
+          end
+        rescue SyntaxError => e
+          e.set_line_number_from_token(token)
+          raise
+        end
+      end
+
+      # Make sure that it's ok to end parsing in the current block.
+      # Effectively this method will throw an exception unless the current block is
+      # of type Document
+      assert_missing_delimitation!
    end

-    def unknown_tag(tag, _params, _tokens)
-      if tag == 'else'.freeze
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else".freeze,
-          block_name: block_name)
-      elsif tag.start_with?('end'.freeze)
-        raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
-          tag: tag,
-          block_name: block_name,
-          block_delimiter: block_delimiter)
+    # warnings of this block and all sub-tags
+    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
+
+      all_warnings
+    end
+
+    def unknown_tag(tag, params, tokens)
+      case tag
+      when 'else'.freeze
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
+                                                 :block_name => block_name))
+      when 'end'.freeze
+        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".freeze, tag: tag)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
      end
    end

@@ -48,31 +96,65 @@ module Liquid
      @block_delimiter ||= "end#{block_name}"
    end

+    def create_variable(token)
+      token.scan(ContentOfVariable) do |content|
+        markup = token.is_a?(Token) ? token.child(content.first) : content.first
+        return Variable.new(markup, @options)
+      end
+      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
+    end
+
+    def render(context)
+      render_all(@nodelist, context)
+    end
+
    protected

-    def parse_body(body, tokens)
-      if parse_context.depth >= MAX_DEPTH
-        raise StackLevelError, "Nesting too deep".freeze
-      end
-      parse_context.depth += 1
-      begin
-        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
-          @blank &&= body.blank?
+    def assert_missing_delimitation!
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
+    end

-          return false if end_tag_name == block_delimiter
-          unless end_tag_name
-            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)
+    def render_all(list, context)
+      output = []
+      context.resource_limits[:render_length_current] = 0
+      context.resource_limits[:render_score_current] += list.length
+
+      list.each do |token|
+        # Break out if we have any unhanded interrupts.
+        break if context.has_interrupt?
+
+        begin
+          # If we get an Interrupt that means the block must stop processing. An
+          # Interrupt is any command that stops block execution such as {% break %}
+          # or {% continue %}
+          if token.is_a? Continue or token.is_a? Break
+            context.push_interrupt(token.interrupt)
+            break
          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)
+          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
-      ensure
-        parse_context.depth -= 1
      end

-      true
+      output.join
+    end
+
+    def render_token(token, context)
+      token_output = (token.respond_to?(:render) ? token.render(context) : token)
+      context.increment_used_resources(:render_length_current, token_output)
+      if context.resource_limits_reached?
+        context.resource_limits[:reached] = true
+        raise MemoryError.new("Memory limits exceeded".freeze)
+      end
+      token_output
    end
  end
 end
--- a/lib/liquid/block_body.rb
+++ b/lib/liquid/block_body.rb
@@ -1,189 +0,0 @@
-module Liquid
-  class BlockBody
-    LiquidTagToken = /\A\s*(\w+)\s*(.*?)\z/o
-    FullToken = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
-    WhitespaceOrNothing = /\A\s*\z/
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
-
-    attr_reader :nodelist
-
-    def initialize
-      @nodelist = []
-      @blank = true
-    end
-
-    def parse(tokenizer, parse_context, &block)
-      parse_context.line_number = tokenizer.line_number
-
-      if tokenizer.for_liquid_tag
-        parse_for_liquid_tag(tokenizer, parse_context, &block)
-      else
-        parse_for_document(tokenizer, parse_context, &block)
-      end
-    end
-
-    private def parse_for_liquid_tag(tokenizer, parse_context)
-      while token = tokenizer.shift
-        unless token.empty? || token =~ WhitespaceOrNothing
-          unless token =~ LiquidTagToken
-            # line isn't empty but didn't match tag syntax, yield and let the
-            # caller raise a syntax error
-            return yield token, token
-          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
-
-    private def parse_for_document(tokenizer, parse_context, &block)
-      while token = tokenizer.shift
-        next if token.empty?
-        case
-        when token.start_with?(TAGSTART)
-          whitespace_handler(token, parse_context)
-          unless token =~ FullToken
-            raise_missing_tag_terminator(token, parse_context)
-          end
-          tag_name = Regexp.last_match(2)
-          markup = Regexp.last_match(4)
-
-          if parse_context.line_number
-            # newlines inside the tag should increase the line number,
-            # particularly important for multiline {% liquid %} tags
-            parse_context.line_number += Regexp.last_match(1).count("\n".freeze) + Regexp.last_match(3).count("\n".freeze)
-          end
-
-          if tag_name == 'liquid'.freeze
-            liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
-            next parse_for_liquid_tag(liquid_tag_tokenizer, parse_context, &block)
-          end
-
-          unless tag = registered_tags[tag_name]
-            # end parsing if we reach an unknown tag and let the caller decide
-            # determine how to proceed
-            return yield tag_name, markup
-          end
-          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-          @blank &&= new_tag.blank?
-          @nodelist << new_tag
-        when token.start_with?(VARSTART)
-          whitespace_handler(token, parse_context)
-          @nodelist << create_variable(token, parse_context)
-          @blank = false
-        else
-          if parse_context.trim_whitespace
-            token.lstrip!
-          end
-          parse_context.trim_whitespace = false
-          @nodelist << token
-          @blank &&= !!(token =~ WhitespaceOrNothing)
-        end
-        parse_context.line_number = tokenizer.line_number
-      end
-
-      yield nil, nil
-    end
-
-    def whitespace_handler(token, parse_context)
-      if token[2] == WhitespaceControl
-        previous_token = @nodelist.last
-        if previous_token.is_a?(String)
-          previous_token.rstrip!
-        end
-      end
-      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
-    end
-
-    def blank?
-      @blank
-    end
-
-    def render(context)
-      render_to_output_buffer(context, '')
-    end
-
-    def render_to_output_buffer(context, output)
-      context.resource_limits.render_score += @nodelist.length
-
-      idx = 0
-      while node = @nodelist[idx]
-        previous_output_size = output.bytesize
-
-        case node
-        when String
-          output << node
-        when Variable
-          render_node(context, output, node)
-        when Block
-          render_node(context, node.blank? ? '' : output, node)
-          break if context.interrupt? # might have happened in a for-block
-        when Continue, Break
-          # If we get an Interrupt that means the block must stop processing. An
-          # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}
-          context.push_interrupt(node.interrupt)
-          break
-        else # Other non-Block tags
-          render_node(context, output, node)
-          break if context.interrupt? # might have happened through an include
-        end
-        idx += 1
-
-        raise_if_resource_limits_reached(context, output.bytesize - previous_output_size)
-      end
-
-      output
-    end
-
-    private
-
-    def render_node(context, output, node)
-      node.render_to_output_buffer(context, output)
-    rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
-      context.handle_error(e, node.line_number)
-    rescue ::StandardError => e
-      line_number = node.is_a?(String) ? nil : node.line_number
-      output << context.handle_error(e, line_number)
-    end
-
-    def raise_if_resource_limits_reached(context, length)
-      context.resource_limits.render_length += length
-      return unless context.resource_limits.reached?
-      raise MemoryError, "Memory limits exceeded".freeze
-    end
-
-    def create_variable(token, parse_context)
-      token.scan(ContentOfVariable) do |content|
-        markup = content.first
-        return Variable.new(markup, parse_context)
-      end
-      raise_missing_variable_terminator(token, parse_context)
-    end
-
-    def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.inspect)
-    end
-
-    def raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect)
-    end
-
-    def registered_tags
-      Template.tags
-    end
-  end
-end
--- a/lib/liquid/condition.rb
+++ b/lib/liquid/condition.rb
@@ -8,55 +8,44 @@ module Liquid
  #
  class Condition #:nodoc:
    @@operators = {
-      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
-      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<'.freeze => :<,
-      '>'.freeze => :>,
+      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '!='.freeze => lambda { |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'.freeze => lambda do |_cond, left, right|
-        if left && right && left.respond_to?(:include?)
-          right = right.to_s if left.is_a?(String)
-          left.include?(right)
-        else
-          false
-        end
-      end,
+      'contains'.freeze => lambda { |cond, left, right|
+        left && right && left.respond_to?(:include?) ? left.include?(right) : false
+      }
    }

    def self.operators
      @@operators
    end

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

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

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

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

    def or(condition)
@@ -81,24 +70,20 @@ module Liquid
      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
    end

-    protected
-
-    attr_reader :child_relation
-
    private

    def equal_variables(left, right)
-      if left.is_a?(Liquid::Expression::MethodLiteral)
-        if right.respond_to?(left.method_name)
-          return right.send(left.method_name)
+      if left.is_a?(Symbol)
+        if right.respond_to?(left)
+          return right.send(left.to_s)
        else
          return nil
        end
      end

-      if right.is_a?(Liquid::Expression::MethodLiteral)
-        if left.respond_to?(right.method_name)
-          return left.send(right.method_name)
+      if right.is_a?(Symbol)
+        if left.respond_to?(right)
+          return left.send(right.to_s)
        else
          return nil
        end
@@ -111,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
-      end
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.left, @node.right,
-          @node.child_condition, @node.attachment
-        ].compact
+      else
+        nil
      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,4 +1,5 @@
 module Liquid
+
  # Context keeps the variable stack and resolves variables, as well as keywords
  #
  #   context['variable'] = 'testing'
@@ -12,44 +13,41 @@ module Liquid
  #
  #   context['bob']  #=> nil  class Context
  class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_accessor :exception_handler

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

      @this_stack_used = false

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

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

-    def warnings
-      @warnings ||= []
+    def increment_used_resources(key, obj)
+      @resource_limits[key] += if obj.kind_of?(String) || obj.kind_of?(Array) || obj.kind_of?(Hash)
+        obj.length
+      else
+        1
+      end
+    end
+
+    def resource_limits_reached?
+      (@resource_limits[:render_length_limit] && @resource_limits[:render_length_current] > @resource_limits[:render_length_limit]) ||
+      (@resource_limits[:render_score_limit]  && @resource_limits[:render_score_current]  > @resource_limits[:render_score_limit] ) ||
+      (@resource_limits[:assign_score_limit]  && @resource_limits[:assign_score_current]  > @resource_limits[:assign_score_limit] )
    end

    def strainer
@@ -62,16 +60,25 @@ module Liquid
    # for that
    def add_filters(filters)
      filters = [filters].flatten.compact
-      @filters += filters
-      @strainer = nil
-    end
+      filters.each do |f|
+        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
+        Strainer.add_known_filter(f)
+      end

-    def apply_global_filter(obj)
-      global_filter.nil? ? obj : global_filter.call(obj)
+      # If strainer is already setup then there's no choice but to use a runtime
+      # extend call. If strainer is not yet created, we can utilize strainers
+      # cached class based API, which avoids busting the method cache.
+      if @strainer
+        filters.each do |f|
+          strainer.extend(f)
+        end
+      else
+        @filters.concat filters
+      end
    end

    # are there any not handled interrupts?
-    def interrupt?
+    def has_interrupt?
      !@interrupts.empty?
    end

@@ -85,12 +92,15 @@ module Liquid
      @interrupts.pop
    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
+
+    def handle_error(e, token=nil)
+      if e.is_a?(Liquid::Error)
+        e.set_line_number_from_token(token)
+      end
+
      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)
@@ -98,9 +108,9 @@ module Liquid
    end

    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push(new_scope = {})
+    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,7 +132,7 @@ module Liquid
    #   end
    #
    #   context['var]  #=> nil
-    def stack(new_scope = nil)
+    def stack(new_scope=nil)
      old_stack_used = @this_stack_used
      if new_scope
        push(new_scope)
@@ -137,25 +147,6 @@ module Liquid
      @this_stack_used = old_stack_used
    end

-    # Creates a new context inheriting resource limits, filters, environment etc.,
-    # but with an isolated scope.
-    def new_isolated_subcontext
-      check_overflow
-
-      Context.build(
-        resource_limits: resource_limits,
-        static_environments: static_environments,
-        static_registers: static_registers
-      ).tap do |subcontext|
-        subcontext.base_scope_depth = base_scope_depth + 1
-        subcontext.exception_renderer = exception_renderer
-        subcontext.filters = @filters
-        subcontext.strainer = nil
-        subcontext.errors = errors
-        subcontext.warnings = warnings
-      end
-    end
-
    def clear_instance_assigns
      @scopes[0] = {}
    end
@@ -181,7 +172,7 @@ module Liquid
      evaluate(Expression.parse(expression))
    end

-    def key?(key)
+    def has_key?(key)
      self[key] != nil
    end

@@ -190,85 +181,52 @@ 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
-        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
-      else
-        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
+      variable = nil
+
+      if scope.nil?
+        @environments.each do |e|
+          variable = lookup_and_evaluate(e, key)
+          unless variable.nil?
+            scope = e
+            break
+          end
+        end
      end

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

-      variable
+      return variable
    end

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

-    protected
-
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
-
    private
-
-    attr_reader :base_scope_depth
-
-    def try_variable_find_in_environments(key, raise_on_not_found:)
-      @environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
-      end
-      @static_environments.each do |environment|
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          return found_variable
-        end
-      end
-      nil
-    end
-
-    def check_overflow
-      raise StackLevelError, "Nesting too deep".freeze if overflow?
-    end
-
-    def overflow?
-      base_scope_depth + @scopes.length > Block::MAX_DEPTH
-    end
-
-    def internal_error
-      # raise and catch to set backtrace and cause on exception
-      raise Liquid::InternalError, 'internal'
-    rescue Liquid::InternalError => exc
-      exc
-    end
-
-    def squash_instance_assigns_with_environments
-      @scopes.last.each_key do |k|
-        @environments.each do |env|
-          if env.key?(k)
-            scopes.last[k] = lookup_and_evaluate(env, k)
-            break
+      def squash_instance_assigns_with_environments
+        @scopes.last.each_key do |k|
+          @environments.each do |env|
+            if env.has_key?(k)
+              scopes.last[k] = lookup_and_evaluate(env, k)
+              break
+            end
          end
        end
-      end
-    end # squash_instance_assigns_with_environments
+      end # squash_instance_assigns_with_environments
  end # Context
 end # Liquid
--- a/lib/liquid/document.rb
+++ b/lib/liquid/document.rb
@@ -1,27 +1,17 @@
 module Liquid
-  class Document < BlockBody
-    def self.parse(tokens, parse_context)
-      doc = new
-      doc.parse(tokens, parse_context)
-      doc
+  class Document < Block
+    def self.parse(tokens, options={})
+      # we don't need markup to open this block
+      super(nil, nil, tokens, options)
    end

-    def parse(tokens, parse_context)
-      super do |end_tag_name, _end_tag_params|
-        unknown_tag(end_tag_name, parse_context) if end_tag_name
-      end
-    rescue SyntaxError => e
-      e.line_number ||= parse_context.line_number
-      raise
+    # There isn't a real delimiter
+    def block_delimiter
+      []
    end

-    def unknown_tag(tag, parse_context)
-      case tag
-      when 'else'.freeze, 'end'.freeze
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag)
-      else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag)
-      end
+    # Document blocks don't need to be terminated since they are not actually opened
+    def assert_missing_delimitation!
    end
  end
 end
--- a/lib/liquid/drop.rb
+++ b/lib/liquid/drop.rb
@@ -1,6 +1,7 @@
 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.
@@ -18,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
-  # or implement the liquid_method_missing(name) method which is a catch all.
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
+  # catch all.
  class Drop
    attr_writer :context

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

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

-    def key?(_name)
+    def has_key?(name)
      true
    end

@@ -54,25 +56,22 @@ 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)
-    end
-
-    def self.invokable_methods
-      @invokable_methods ||= begin
+      unless @invokable_methods
        blacklist = Liquid::Drop.public_instance_methods + [:each]
-
        if include?(Enumerable)
          blacklist += Enumerable.public_instance_methods
          blacklist -= [:sort, :count, :first, :min, :max, :include?]
        end
-
        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
-        Set.new(whitelist.map(&:to_s))
+        @invokable_methods = Set.new(whitelist.map(&:to_s))
      end
+      @invokable_methods.include?(method_name.to_s)
    end
  end
 end
--- a/lib/liquid/errors.rb
+++ b/lib/liquid/errors.rb
@@ -1,10 +1,9 @@
 module Liquid
  class Error < ::StandardError
    attr_accessor :line_number
-    attr_accessor :template_name
    attr_accessor :markup_context

-    def to_s(with_prefix = true)
+    def to_s(with_prefix=true)
      str = ""
      str << message_prefix if with_prefix
      str << super()
@@ -17,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 << if is_a?(SyntaxError)
-        "Liquid syntax error"
+      if is_a?(SyntaxError)
+        str << "Liquid syntax error"
      else
-        "Liquid error"
+        str << "Liquid error"
      end

      if line_number
-        str << " ("
-        str << template_name << " " if template_name
-        str << "line " << line_number.to_s << ")"
+        str << " (line #{line_number})"
      end

      str << ": "
@@ -38,19 +49,12 @@ module Liquid
    end
  end

-  ArgumentError = Class.new(Error)
-  ContextError = Class.new(Error)
-  FileSystemError = Class.new(Error)
-  StandardError = Class.new(Error)
-  SyntaxError = Class.new(Error)
-  StackLevelError = Class.new(Error)
-  TaintedError = Class.new(Error)
-  MemoryError = Class.new(Error)
-  ZeroDivisionError = Class.new(Error)
-  FloatDomainError = Class.new(Error)
-  UndefinedVariable = Class.new(Error)
-  UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter = Class.new(Error)
-  MethodOverrideError = Class.new(Error)
-  InternalError = Class.new(Error)
+  class ArgumentError < Error; end
+  class ContextError < Error; end
+  class FileSystemError < Error; end
+  class StandardError < Error; end
+  class SyntaxError < Error; end
+  class StackLevelError < Error; end
+  class TaintedError < Error; end
+  class MemoryError < Error; end
 end
--- a/lib/liquid/expression.rb
+++ b/lib/liquid/expression.rb
@@ -1,49 +1,33 @@
 module Liquid
  class Expression
-    class MethodLiteral
-      attr_reader :method_name, :to_s
-
-      def initialize(method_name, to_s)
-        @method_name = method_name
-        @to_s = to_s
-      end
-
-      def to_liquid
-        to_s
-      end
-    end
-
    LITERALS = {
      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true'.freeze => true,
+      'true'.freeze  => true,
      'false'.freeze => false,
-      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
-      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
-    }.freeze
-
-    SINGLE_QUOTED_STRING = /\A'(.*)'\z/m
-    DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m
-    INTEGERS_REGEX       = /\A(-?\d+)\z/
-    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/
-    RANGES_REGEX         = /\A\((\S+)\.\.(\S+)\)\z/
+      'blank'.freeze => :blank?,
+      'empty'.freeze => :empty?
+    }

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

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

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

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

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

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

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

 class TrueClass
-  def to_liquid # :nodoc:
+  def to_liquid  # :nodoc:
    self
  end
 end
--- a/lib/liquid/file_system.rb
+++ b/lib/liquid/file_system.rb
@@ -8,13 +8,13 @@ module Liquid
  #
  # Example:
  #
-  #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
-  #   liquid = Liquid::Template.parse(template)
+  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  # liquid = Liquid::Template.parse(template)
  #
  # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
  class BlankFileSystem
    # Called by Liquid to retrieve a template file
-    def read_template_file(_template_path)
+    def read_template_file(template_path, context)
      raise FileSystemError, "This liquid context does not allow includes."
    end
  end
@@ -26,10 +26,10 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path")
+  # file_system = Liquid::LocalFileSystem.new("/some/path")
  #
-  #   file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
-  #   file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
+  # file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
+  # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_mypartial.liquid"
  #
  # Optionally in the second argument you can specify a custom pattern for template filenames.
  # The Kernel::sprintf format specification is used.
@@ -37,9 +37,9 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+  # file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
  #
-  #   file_system.full_path("index") # => "/some/path/index.html"
+  # file_system.full_path("index") # => "/some/path/index.html"
  #
  class LocalFileSystem
    attr_accessor :root
@@ -49,15 +49,15 @@ module Liquid
      @pattern = pattern
    end

-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
      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 template_path =~ %r{\A[^./][a-zA-Z0-9_/]+\z}
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/

      full_path = if template_path.include?('/'.freeze)
        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
@@ -65,7 +65,7 @@ module Liquid
        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,42 +0,0 @@
-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
@@ -2,9 +2,10 @@ 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

@@ -22,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
-      end
+        "#{vars[$1.to_sym]}"
+      }
    end

    def deep_fetch_translation(name)
      name.split('.'.freeze).reduce(locale) do |level, cur|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
      end
    end
  end
--- a/lib/liquid/interrupts.rb
+++ b/lib/liquid/interrupts.rb
@@ -1,9 +1,10 @@
 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)
+    def initialize(message=nil)
      @message = message || "interrupt".freeze
    end
  end
--- a/lib/liquid/lexer.rb
+++ b/lib/liquid/lexer.rb
@@ -11,36 +11,35 @@ module Liquid
      '('.freeze => :open_round,
      ')'.freeze => :close_round,
      '?'.freeze => :question,
-      '-'.freeze => :dash,
-    }.freeze
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
+      '-'.freeze => :dash
+    }
+    IDENTIFIER = /\w+/
    SINGLE_STRING_LITERAL = /'[^\']*'/
    DOUBLE_STRING_LITERAL = /"[^\"]*"/
    NUMBER_LITERAL = /-?\d+(\.\d+)?/
    DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
-    WHITESPACE_OR_NOTHING = /\s*/
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/

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

    def tokenize
      @output = []

-      until @ss.eos?
-        @ss.skip(WHITESPACE_OR_NOTHING)
-        break if @ss.eos?
-        tok = if t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
-        elsif t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
-        elsif t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
-        elsif t = @ss.scan(NUMBER_LITERAL) then [:number, t]
-        elsif t = @ss.scan(IDENTIFIER) then [:id, t]
-        elsif t = @ss.scan(DOTDOT) then [:dotdot, t]
+      while !@ss.eos?
+        @ss.skip(/\s*/)
+        tok = case
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
        else
          c = @ss.getch
          if s = SPECIALS[c]
-            [s, c]
+            [s,c]
          else
            raise SyntaxError, "Unexpected character #{c}"
          end
--- 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,14 +13,10 @@
      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}"
-      unexpected_else: "%{block_name} tag does not expect 'else' tag"
-      unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
+      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"
      tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
      variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
      tag_never_closed: "'%{block_name}' tag was never closed"
      meta_syntax_error: "Liquid syntax error: #{e.message}"
      table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
-      render: "Syntax error in tag 'render' - Template name must be a quoted string"
-    argument:
-      include: "Argument error in tag 'include' - Illegal template name"
--- a/lib/liquid/module_ex.rb
+++ b/lib/liquid/module_ex.rb
@@ -0,0 +1,62 @@
+# 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
+# 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,38 +0,0 @@
-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 partial=(value)
-      @partial = value
-      @options = value ? partial_options : @template_options
-      @error_mode = @options[:error_mode] || Template.error_mode
-      value
-    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
@@ -44,14 +44,11 @@ module Liquid
      tok[0] == type
    end

-    SINGLE_TOKEN_EXPRESSION_TYPES = [:string, :number].freeze
-    private_constant :SINGLE_TOKEN_EXPRESSION_TYPES
-
    def expression
      token = @tokens[@p]
      if token[0] == :id
        variable_signature
-      elsif SINGLE_TOKEN_EXPRESSION_TYPES.include?(token[0])
+      elsif [:string, :number].include? token[0]
        consume
      elsif token.first == :open_round
        consume
@@ -78,7 +75,14 @@ module Liquid

    def variable_signature
      str = consume(:id)
-      while look(:open_square)
+      while consume?(:dash)
+        str << "-".freeze
+        str << consume(:id)
+      end
+      if consume?(:question)
+        str << "?".freeze
+      end
+      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,25 +1,25 @@
 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
          return strict_parse_with_error_context(markup)
        rescue SyntaxError => e
-          parse_context.warnings << e
+          e.set_line_number_from_token(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,18 +0,0 @@
-module Liquid
-  class PartialCache
-    def self.load(template_name, context:, parse_context:)
-      cached_partials = (context.registers[:cached_partials] ||= {})
-      cached = cached_partials[template_name]
-      return cached if cached
-
-      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
-      source = file_system.read_template_file(template_name)
-      parse_context.partial = true
-
-      partial = Liquid::Template.parse(source, parse_context)
-      cached_partials[template_name] = partial
-    ensure
-      parse_context.partial = false
-    end
-  end
-end
--- a/lib/liquid/profiler.rb
+++ b/lib/liquid/profiler.rb
@@ -1,11 +1,9 @@
-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'.
-  # Then, to profile a parse/render cycle, pass the <tt>profile: true</tt> option to <tt>Liquid::Template.parse</tt>.
-  # After <tt>Liquid::Template#render</tt> is called, the template object makes available an instance of this
+  # To enable profiling, pass the <tt>profile: true</tt> option to <tt>Liquid::Template.parse</tt>. Then, after
+  # <tt>Liquid::Template#render</tt> is called, the template object makes available an instance of this
  # class via the <tt>Liquid::Template#profiler</tt> method.
  #
  #   template = Liquid::Template.parse(template_content, profile: true)
@@ -19,7 +17,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,15 +44,17 @@ module Liquid
    class Timing
      attr_reader :code, :partial, :line_number, :children

-      def initialize(node, partial)
-        @code        = node.respond_to?(:raw) ? node.raw : node
+      def initialize(token, partial)
+        @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)
-        new(node, partial).tap(&:start)
+      def self.start(token, partial)
+        new(token, partial).tap do |t|
+          t.start
+        end
      end

      def start
@@ -70,11 +70,11 @@ module Liquid
      end
    end

-    def self.profile_node_render(node)
-      if Profiler.current_profile && node.respond_to?(:render)
-        Profiler.current_profile.start_node(node)
+    def self.profile_token_render(token)
+      if Profiler.current_profile && token.respond_to?(:render)
+        Profiler.current_profile.start_token(token)
        output = yield
-        Profiler.current_profile.end_node(node)
+        Profiler.current_profile.end_token(token)
        output
      else
        yield
@@ -132,11 +132,11 @@ module Liquid
      @root_timing.children.length
    end

-    def start_node(node)
-      @timing_stack.push(Timing.start(node, current_partial))
+    def start_token(token)
+      @timing_stack.push(Timing.start(token, current_partial))
    end

-    def end_node(_node)
+    def end_token(token)
      timing = @timing_stack.pop
      timing.finish

@@ -154,5 +154,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,23 +1,23 @@
 module Liquid
-  class BlockBody
-    def render_node_with_profiling(context, output, node)
-      Profiler.profile_node_render(node) do
-        render_node_without_profiling(context, output, node)
+  class Block < Tag
+    def render_token_with_profiling(token, context)
+      Profiler.profile_token_render(token) do
+        render_token_without_profiling(token, context)
      end
    end

-    alias_method :render_node_without_profiling, :render_node
-    alias_method :render_node, :render_node_with_profiling
+    alias_method :render_token_without_profiling, :render_token
+    alias_method :render_token, :render_token_with_profiling
  end

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

-    alias_method :render_to_output_buffer_without_profiling, :render_to_output_buffer
-    alias_method :render_to_output_buffer, :render_to_output_buffer_with_profiling
+    alias_method :render_without_profiling, :render
+    alias_method :render, :render_with_profiling
  end
 end
--- a/lib/liquid/range_lookup.rb
+++ b/lib/liquid/range_lookup.rb
@@ -16,22 +16,7 @@ module Liquid
    end

    def evaluate(context)
-      start_int = to_integer(context.evaluate(@start_obj))
-      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
+      context.evaluate(@start_obj).to_i..context.evaluate(@end_obj).to_i
    end
  end
 end
--- a/lib/liquid/resource_limits.rb
+++ b/lib/liquid/resource_limits.rb
@@ -1,23 +0,0 @@
-module Liquid
-  class ResourceLimits
-    attr_accessor :render_length, :render_score, :assign_score,
-      :render_length_limit, :render_score_limit, :assign_score_limit
-
-    def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit = limits[:render_score_limit]
-      @assign_score_limit = limits[:assign_score_limit]
-      reset
-    end
-
-    def reached?
-      (@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
-      @render_length = @render_score = @assign_score = 0
-    end
-  end
-end
--- a/lib/liquid/standardfilters.rb
+++ b/lib/liquid/standardfilters.rb
@@ -2,21 +2,16 @@ require 'cgi'
 require 'bigdecimal'

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

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

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

@@ -48,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)
-      length = length ? Utils.to_integer(length) : 1
+    def slice(input, offset, length=nil)
+      offset = Integer(offset)
+      length = length ? Integer(length) : 1

      if input.is_a?(Array)
        input.slice(offset, length) || []
@@ -73,22 +59,18 @@ module Liquid

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

    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 - 1
+      l = words.to_i - 1
      l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ".freeze).concat(truncate_string.to_s) : input
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
    end

    # Split input string into an array of substrings separated by given pattern.
@@ -97,7 +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)
@@ -114,9 +96,7 @@ module Liquid

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

    # Remove all newlines from the string
@@ -133,61 +113,12 @@ module Liquid
    # provide optional property with which to sort an array of hashes or drops
    def sort(input, property = nil)
      ary = InputIterator.new(input)
-
-      return [] if ary.empty?
-
      if property.nil?
-        ary.sort do |a, b|
-          nil_safe_compare(a, b)
-        end
-      elsif ary.all? { |el| el.respond_to?(:[]) }
-        begin
-          ary.sort { |a, b| nil_safe_compare(a[property], b[property]) }
-        rescue TypeError
-          raise_property_error(property)
-        end
-      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)
-
-      return [] if ary.empty?
-
-      if property.nil?
-        ary.sort do |a, b|
-          nil_safe_casecmp(a, b)
-        end
-      elsif ary.all? { |el| el.respond_to?(:[]) }
-        begin
-          ary.sort { |a, b| nil_safe_casecmp(a[property], b[property]) }
-        rescue TypeError
-          raise_property_error(property)
-        end
-      end
-    end
-
-    # Filter the elements of an array to those with a certain property value.
-    # By default the target is any truthy value.
-    def where(input, property, target_value = nil)
-      ary = InputIterator.new(input)
-
-      if ary.empty?
-        []
-      elsif ary.first.respond_to?(:[]) && target_value.nil?
-        begin
-          ary.select { |item| item[property] }
-        rescue TypeError
-          raise_property_error(property)
-        end
-      elsif ary.first.respond_to?(:[])
-        begin
-          ary.select { |item| item[property] == target_value }
-        rescue TypeError
-          raise_property_error(property)
-        end
+        ary.sort
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
+        ary.sort {|a,b| a[property] <=> b[property] }
+      elsif ary.first.respond_to?(property)
+        ary.sort {|a,b| a.send(property) <=> b.send(property) }
      end
    end

@@ -195,17 +126,10 @@ module Liquid
    # provide optional property with which to determine uniqueness
    def uniq(input, property = nil)
      ary = InputIterator.new(input)
-
      if property.nil?
-        ary.uniq
-      elsif ary.empty? # The next two cases assume a non-empty array.
-        []
-      elsif ary.first.respond_to?(:[])
-        begin
-          ary.uniq { |a| a[property] }
-        rescue TypeError
-          raise_property_error(property)
-        end
+        input.uniq
+      elsif input.first.respond_to?(:[])
+        input.uniq{ |a| a[property] }
      end
    end

@@ -223,50 +147,29 @@ module Liquid
        if property == "to_liquid".freeze
          e
        elsif e.respond_to?(:[])
-          r = e[property]
-          r.is_a?(Proc) ? r.call : r
-        end
-      end
-    rescue TypeError
-      raise_property_error(property)
-    end
-
-    # Remove nils within an array
-    # provide optional property with which to check for nil
-    def compact(input, property = nil)
-      ary = InputIterator.new(input)
-
-      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)
+          e[property]
        end
      end
    end

    # Replace occurrences of a string with another
    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 = ''.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, ''.freeze)
+      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, ''.freeze)
+      input.to_s.sub(string, ''.freeze)
    end

    # add one string to another
@@ -274,13 +177,6 @@ module Liquid
      input.to_s + string.to_s
    end

-    def concat(input, array)
-      unless array.respond_to?(:to_ary)
-        raise ArgumentError, "concat filter requires an array argument"
-      end
-      InputIterator.new(input).concat(array)
-    end
-
    # prepend a string to another
    def prepend(input, string)
      string.to_s + input.to_s
@@ -325,7 +221,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
@@ -348,12 +244,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, :+)
@@ -372,88 +262,69 @@ 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
-    rescue ::FloatDomainError => e
-      raise Liquid::FloatDomainError, e.message
+      to_number(input).ceil.to_i
    end

    def floor(input)
-      Utils.to_number(input).floor.to_i
-    rescue ::FloatDomainError => e
-      raise Liquid::FloatDomainError, e.message
+      to_number(input).floor.to_i
    end

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

    private

-    def raise_property_error(property)
-      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
+    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 to_date(obj)
+      return obj if obj.respond_to?(:strftime)
+
+      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

@@ -470,30 +341,13 @@ module Liquid
      end

      def join(glue)
-        to_a.join(glue.to_s)
-      end
-
-      def concat(args)
-        to_a.concat(args)
+        to_a.join(glue)
      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|
          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
--- a/lib/liquid/strainer.rb
+++ b/lib/liquid/strainer.rb
@@ -1,19 +1,19 @@
 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
+    @@filters = []
+    @@known_filters = Set.new
+    @@known_methods = Set.new
    @@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) }
+      hash[filters] = Class.new(Strainer) do
+        filters.each { |f| include f }
      end
    end

@@ -21,46 +21,43 @@ module Liquid
      @context = context
    end

-    class << self
-      attr_reader :filter_methods
+    def self.global_filter(filter)
+      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
+      add_known_filter(filter)
+      @@filters << filter unless @@filters.include?(filter)
    end

-    def self.add_filter(filter)
-      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-      unless include?(filter)
-        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
-        if invokable_non_public_methods.any?
-          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
-        else
-          send(:include, filter)
-          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-        end
+    def self.add_known_filter(filter)
+      unless @@known_filters.include?(filter)
+        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
+        new_methods = filter.instance_methods.map(&:to_s)
+        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
+        @@known_methods.merge(new_methods)
+        @@known_filters.add(filter)
      end
    end

-    def self.global_filter(filter)
-      @@strainer_class_cache.clear
-      @@global_strainer.add_filter(filter)
-    end
-
-    def self.invokable?(method)
-      @filter_methods.include?(method.to_s)
+    def self.strainer_class_cache
+      @@strainer_class_cache
    end

    def self.create(context, filters = [])
-      @@strainer_class_cache[filters].new(context)
+      filters = @@filters + filters
+      strainer_class_cache[filters].new(context)
    end

    def invoke(method, *args)
-      if self.class.invokable?(method)
+      if invokable?(method)
        send(method, *args)
-      elsif @context&.strict_filters
-        raise Liquid::UndefinedFilter, "undefined filter #{method}"
      else
        args.first
      end
    rescue ::ArgumentError => e
-      raise Liquid::ArgumentError, e.message, e.backtrace
+      raise Liquid::ArgumentError.new(e.message)
+    end
+
+    def invokable?(method)
+      @@known_methods.include?(method.to_s) && respond_to?(method)
    end
  end
 end
--- a/lib/liquid/tablerowloop_drop.rb
+++ b/lib/liquid/tablerowloop_drop.rb
@@ -1,62 +0,0 @@
-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,27 +1,26 @@
 module Liquid
  class Tag
-    attr_reader :nodelist, :tag_name, :line_number, :parse_context
-    alias_method :options, :parse_context
+    attr_accessor :options, :line_number
+    attr_reader :nodelist, :warnings
    include ParserSwitching

    class << self
-      def parse(tag_name, markup, tokenizer, parse_context)
-        tag = new(tag_name, markup, parse_context)
-        tag.parse(tokenizer)
+      def parse(tag_name, markup, tokens, options)
+        tag = new(tag_name, markup, options)
+        tag.parse(tokens)
        tag
      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
-      @line_number = parse_context.line_number
+      @options    = options
    end

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

    def raw
@@ -32,18 +31,10 @@ 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?
      false
    end
--- a/lib/liquid/tags/assign.rb
+++ b/lib/liquid/tags/assign.rb
@@ -1,4 +1,5 @@
 module Liquid
+
  # Assign sets a variable in your template.
  #
  #   {% assign foo = 'monkey' %}
@@ -10,53 +11,27 @@ module Liquid
  class Assign < Tag
    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om

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

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

    def blank?
      true
    end
-
-    private
-
-    def assign_score_of(val)
-      if val.instance_of?(String)
-        val.bytesize
-      elsif val.instance_of?(Array) || val.instance_of?(Hash)
-        sum = 1
-        # Uses #each to avoid extra allocations.
-        val.each { |child| sum += assign_score_of(child) }
-        sum
-      else
-        1
-      end
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [@node.from]
-      end
-    end
  end

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

  Template.register_tag('break'.freeze, Break)
--- a/lib/liquid/tags/capture.rb
+++ b/lib/liquid/tags/capture.rb
@@ -11,23 +11,22 @@ module Liquid
  # in a sidebar or footer.
  #
  class Capture < Block
-    Syntax = /(#{VariableSignature}+)/o
+    Syntax = /(\w+)/

    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to = $1
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.capture")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
      end
    end

-    def render_to_output_buffer(context, output)
-      previous_output_size = output.bytesize
-      super
+    def render(context)
+      output = super
      context.scopes.last[@to] = output
-      context.resource_limits.assign_score += (output.bytesize - previous_output_size)
-      output
+      context.increment_used_resources(:assign_score_current, output)
+      ''.freeze
    end

    def blank?
--- a/lib/liquid/tags/case.rb
+++ b/lib/liquid/tags/case.rb
@@ -3,29 +3,23 @@ module Liquid
    Syntax     = /(#{QuotedFragment})/o
    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om

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

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

-    def parse(tokens)
-      body = BlockBody.new
-      body = @blocks.last.attachment while parse_body(body, tokens)
-    end
-
    def nodelist
-      @blocks.map(&:attachment)
+      @blocks.flat_map(&:attachment)
    end

    def unknown_tag(tag, markup, tokens)
+      @nodelist = []
      case tag
      when 'when'.freeze
        record_when_condition(markup)
@@ -36,56 +30,49 @@ module Liquid
      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 render_all(block.attachment, context) if execute_else_block
          elsif block.evaluate(context)
            execute_else_block = false
-            block.attachment.render_to_output_buffer(context, output)
+            output << render_all(block.attachment, context)
          end
        end
+        output
      end
-
-      output
    end

    private

    def record_when_condition(markup)
-      body = BlockBody.new
-
      while markup
-        unless markup =~ WhenSyntax
-          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when".freeze)
+        # Create a new nodelist and assign it to the new block
+        if not markup =~ WhenSyntax
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
        end

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

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

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

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

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

-    def unknown_tag(_tag, _markup, _tokens)
+    def unknown_tag(tag, markup, tokens)
    end

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

-    attr_reader :variables
-
    def initialize(tag_name, markup, options)
      super
      case markup
      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
-        @name = Expression.parse(Regexp.last_match(1))
+        @variables = variables_from_string($2)
+        @name = Expression.parse($1)
      when SimpleSyntax
        @variables = variables_from_string(markup)
        @name = @variables.to_s
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
      end
    end

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

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

    private
@@ -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,4 +1,5 @@
 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.
@@ -23,13 +24,14 @@ 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
-      output
+      value.to_s
    end
+
+    private
  end

  Template.register_tag('decrement'.freeze, Decrement)
--- a/lib/liquid/tags/echo.rb
+++ b/lib/liquid/tags/echo.rb
@@ -1,24 +0,0 @@
-module Liquid
-  # Echo outputs an expression
-  #
-  #   {% echo monkey %}
-  #   {% echo user.name %}
-  #
-  # This is identical to variable output syntax, like {{ foo }}, but works
-  # inside {% liquid %} tags. The full syntax is supported, including filters:
-  #
-  #   {% echo user | link %}
-  #
-  class Echo < Tag
-    def initialize(tag_name, markup, parse_context)
-      super
-      @variable = Variable.new(markup, parse_context)
-    end
-
-    def render(context)
-      @variable.render_to_output_buffer(context, '')
-    end
-  end
-
-  Template.register_tag('echo'.freeze, Echo)
-end
--- a/lib/liquid/tags/for.rb
+++ b/lib/liquid/tags/for.rb
@@ -1,4 +1,5 @@
 module Liquid
+
  # "For" iterates over an array or collection.
  # Several useful variables are available to you within the loop.
  #
@@ -23,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:
  #
@@ -41,68 +42,108 @@ module Liquid
  #                   where 0 is the last item.
  # forloop.first:: Returns true if the item is the first item.
  # forloop.last:: Returns true if the item is the last item.
-  # forloop.parentloop:: Provides access to the parent loop, if present.
  #
  class For < Block
    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o

-    attr_reader :collection_name, :variable_name, :limit, :from
-
    def initialize(tag_name, markup, options)
      super
-      @from = @limit = nil
      parse_with_selected_parser(markup)
-      @for_block = BlockBody.new
-      @else_block = nil
-    end
-
-    def parse(tokens)
-      return unless parse_body(@for_block, tokens)
-      parse_body(@else_block, tokens)
+      @nodelist = @for_block = []
    end

    def nodelist
-      @else_block ? [@for_block, @else_block] : [@for_block]
+      if @else_block
+        @for_block + @else_block
+      else
+        @for_block
+      end
    end

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

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

-      if segment.empty?
-        render_else(context, output)
+      collection = context.evaluate(@collection_name)
+      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
+
+      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)
+          }
+
+          result << render_all(@for_block, 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)
-        collection_name = Regexp.last_match(2)
-        @reversed = !!Regexp.last_match(3)
+        @variable_name = $1
+        collection_name = $2
+        @reversed = $3
        @name = "#{@variable_name}-#{collection_name}"
        @collection_name = Expression.parse(collection_name)
        markup.scan(TagAttributes) do |key, value|
          set_attribute(key, value)
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.for".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
      end
    end

    def strict_parse(markup)
      p = Parser.new(markup)
      @variable_name = p.consume(:id)
-      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in".freeze) unless p.id?('in'.freeze)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
      collection_name = p.expression
      @name = "#{@variable_name}-#{collection_name}"
      @collection_name = Expression.parse(collection_name)
@@ -110,7 +151,7 @@ module Liquid

      while p.look(:id) && p.look(:colon, 1)
        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
-          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute".freeze)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
        end
        p.consume
        set_attribute(attribute, p.expression)
@@ -120,69 +161,6 @@ 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'.freeze] = 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'.freeze
@@ -196,18 +174,12 @@ module Liquid
      end
    end

-    def render_else(context, output)
-      if @else_block
-        @else_block.render_to_output_buffer(context, output)
-      else
-        output
-      end
+    def render_else(context)
+      return @else_block ? [render_all(@else_block, context)] : ''.freeze
    end

-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        (super + [@node.limit, @node.from, @node.collection_name]).compact
-      end
+    def iterable?(collection)
+      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
    end
  end

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

    def initialize(tag_name, markup, options)
      super
@@ -23,12 +21,7 @@ module Liquid
    end

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

    def unknown_tag(tag, markup, tokens)
@@ -39,84 +32,74 @@ module Liquid
      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 render_all(block.attachment, context)
          end
        end
+        ''.freeze
      end
-
-      output
    end

    private

-    def push_block(tag, markup)
-      block = if tag == 'else'.freeze
-        ElseCondition.new
-      else
-        parse_with_selected_parser(markup)
+      def push_block(tag, markup)
+        block = if tag == 'else'.freeze
+          ElseCondition.new
+        else
+          parse_with_selected_parser(markup)
+        end
+
+        @blocks.push(block)
+        @nodelist = block.attach(Array.new)
      end

-      @blocks.push(block)
-      block.attach(BlockBody.new)
-    end
+      def lax_parse(markup)
+        expressions = markup.scan(ExpressionsAndOperators)
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax

-    def lax_parse(markup)
-      expressions = markup.scan(ExpressionsAndOperators)
-      raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless expressions.pop =~ Syntax
+        condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))

-      condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+        while not expressions.empty?
+          operator = expressions.pop.to_s.strip

-      until expressions.empty?
-        operator = expressions.pop.to_s.strip
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax

-        raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless expressions.pop.to_s =~ Syntax
+          new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
+          new_condition.send(operator, condition)
+          condition = new_condition
+        end

-        new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
-        raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless BOOLEAN_OPERATORS.include?(operator)
-        new_condition.send(operator, condition)
-        condition = new_condition
+        condition
      end

-      condition
-    end
+      def strict_parse(markup)
+        p = Parser.new(markup)

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

-    def parse_binary_comparisons(p)
-      condition = parse_comparison(p)
-      first_condition = condition
-      while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
-        child_condition = parse_comparison(p)
-        condition.send(op, child_condition)
-        condition = child_condition
+        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
-      first_condition
-    end

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

  Template.register_tag('if'.freeze, If)
--- a/lib/liquid/tags/ifchanged.rb
+++ b/lib/liquid/tags/ifchanged.rb
@@ -1,17 +1,18 @@
 module Liquid
  class Ifchanged < Block
-    def render_to_output_buffer(context, output)
-      context.stack do
-        block_output = ''
-        super(context, block_output)

-        if block_output != context.registers[:ifchanged]
-          context.registers[:ifchanged] = block_output
-          output << block_output
+    def render(context)
+      context.stack do
+
+        output = super
+
+        if output != context.registers[:ifchanged]
+          context.registers[:ifchanged] = output
+          output
+        else
+          ''.freeze
        end
      end
-
-      output
    end
  end

--- a/lib/liquid/tags/include.rb
+++ b/lib/liquid/tags/include.rb
@@ -1,4 +1,5 @@
 module Liquid
+
  # Include allows templates to relate with other templates
  #
  # Simply include another template:
@@ -16,89 +17,90 @@ module Liquid
  class Include < Tag
    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o

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

      if markup =~ Syntax

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

-        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
-        @template_name_expr = Expression.parse(template_name)
-        @attributes = {}
+        @variable_name = Expression.parse(variable_name || template_name[1..-2])
+        @context_variable_name = template_name[1..-2].split('/'.freeze).last
+        @template_name = Expression.parse(template_name)
+        @attributes    = {}

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

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

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

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

-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context
-      )
-
-      context_variable_name = template_name.split('/'.freeze).last
-
-      variable = if @variable_name_expr
-        context.evaluate(@variable_name_expr)
-      else
-        context.find_variable(template_name, raise_on_not_found: false)
-      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|
-              context[context_variable_name] = var
-              partial.render_to_output_buffer(context, output)
-            end
-          else
-            context[context_variable_name] = variable
-            partial.render_to_output_buffer(context, output)
-          end
+      context.stack do
+        @attributes.each do |key, value|
+          context[key] = context.evaluate(value)
        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
+        if variable.is_a?(Array)
+          variable.collect do |var|
+            context[@context_variable_name] = var
+            partial.render(context)
+          end
+        else
+          context[@context_variable_name] = variable
+          partial.render(context)
+        end
      end
    end
+
+    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
+
+        # make read_template_file call backwards-compatible.
+        case file_system.method(:read_template_file).arity
+        when 1
+          file_system.read_template_file(context.evaluate(@template_name))
+        when 2
+          file_system.read_template_file(context.evaluate(@template_name), context)
+        else
+          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
+        end
+      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)
--- a/lib/liquid/tags/increment.rb
+++ b/lib/liquid/tags/increment.rb
@@ -20,12 +20,10 @@ module Liquid
      @variable = markup.strip
    end

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

--- a/lib/liquid/tags/raw.rb
+++ b/lib/liquid/tags/raw.rb
@@ -1,45 +1,16 @@
 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 = ''
+      @nodelist ||= []
+      @nodelist.clear
      while token = tokens.shift
        if token =~ FullTokenPossiblyInvalid
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != "".freeze
-          return if block_delimiter == Regexp.last_match(2)
+          @nodelist << $1 if $1 != "".freeze
+          return if block_delimiter == $2
        end
-        @body << token unless token.empty?
-      end
-
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)
-    end
-
-    def render_to_output_buffer(_context, output)
-      output << @body
-      output
-    end
-
-    def nodelist
-      [@body]
-    end
-
-    def blank?
-      @body.empty?
-    end
-
-    protected
-
-    def ensure_valid_markup(tag_name, markup, parse_context)
-      unless markup =~ Syntax
-        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name)
+        @nodelist << token if not token.empty?
      end
    end
  end
--- a/lib/liquid/tags/render.rb
+++ b/lib/liquid/tags/render.rb
@@ -1,54 +0,0 @@
-module Liquid
-  class Render < Tag
-    SYNTAX = /(#{QuotedString})#{QuotedFragment}*/o
-
-    attr_reader :template_name_expr, :attributes
-
-    def initialize(tag_name, markup, options)
-      super
-
-      raise SyntaxError, options[:locale].t("errors.syntax.render".freeze) unless markup =~ SYNTAX
-
-      template_name = Regexp.last_match(1)
-
-      @template_name_expr = Expression.parse(template_name)
-
-      @attributes = {}
-      markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = Expression.parse(value)
-      end
-    end
-
-    def render_to_output_buffer(context, output)
-      # Though we evaluate this here we will only ever parse it as a string literal.
-      template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
-
-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context
-      )
-
-      inner_context = context.new_isolated_subcontext
-      inner_context.template_name = template_name
-      inner_context.partial = true
-      @attributes.each do |key, value|
-        inner_context[key] = context.evaluate(value)
-      end
-      partial.render_to_output_buffer(inner_context, output)
-
-      output
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.template_name_expr,
-        ] + @node.attributes.values
-      end
-    end
-  end
-
-  Template.register_tag('render'.freeze, Render)
-end
--- a/lib/liquid/tags/table_row.rb
+++ b/lib/liquid/tags/table_row.rb
@@ -2,24 +2,22 @@ module Liquid
  class TableRow < Block
    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o

-    attr_reader :variable_name, :collection_name, :attributes
-
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @variable_name = Regexp.last_match(1)
-        @collection_name = Expression.parse(Regexp.last_match(2))
+        @variable_name = $1
+        @collection_name = Expression.parse($2)
        @attributes = {}
        markup.scan(TagAttributes) do |key, value|
          @attributes[key] = Expression.parse(value)
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.table_row".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
      end
    end

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

      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
@@ -30,34 +28,44 @@ module Liquid

      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'.freeze] = 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,
+            'index0'.freeze    => index,
+            '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
-            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
+          col += 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
-
-      output << "</tr>\n"
-      output
-    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        super + @node.attributes.values + [@node.collection_name]
-      end
+      result << "</tr>\n"
+      result
    end
  end

--- a/lib/liquid/tags/unless.rb
+++ b/lib/liquid/tags/unless.rb
@@ -1,28 +1,29 @@
-require_relative 'if'
+require File.dirname(__FILE__) + '/if'

 module Liquid
  # Unless is a conditional just like 'if' but works on the inverse logic.
  #
-  #   {% unless x < 0 %} x is greater than zero {% endunless %}
+  #   {% unless x < 0 %} x is greater than zero {% end %}
  #
  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 render_all(first_block.attachment, 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 render_all(block.attachment, context)
          end
        end
-      end

-      output
+        ''.freeze
+      end
    end
  end

--- a/lib/liquid/template.rb
+++ b/lib/liquid/template.rb
@@ -1,4 +1,5 @@
 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.
@@ -13,21 +14,21 @@ module Liquid
  #   template.render('user_name' => 'bob')
  #
  class Template
-    attr_accessor :root
-    attr_reader :resource_limits, :warnings
+    DEFAULT_OPTIONS = {
+      :locale => I18n.new
+    }

+    attr_accessor :root, :resource_limits
    @@file_system = BlankFileSystem.new

    class TagRegistry
-      include Enumerable
-
      def initialize
-        @tags = {}
+        @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 +44,10 @@ module Liquid
        @cache.delete(tag_name)
      end

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

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

@@ -69,11 +66,6 @@ module Liquid
      # :error raises an error when tainted output is used
      attr_writer :taint_mode

-      attr_accessor :default_exception_renderer
-      Template.default_exception_renderer = lambda do |exception|
-        exception
-      end
-
      def file_system
        @@file_system
      end
@@ -91,11 +83,11 @@ module Liquid
      end

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

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

      # Pass a module with filter methods which should be available
@@ -118,8 +110,7 @@ module Liquid
    end

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

    # Parse source code.
@@ -128,12 +119,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), parse_context)
-      @warnings = parse_context.warnings
+      @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
+      @warnings = nil
      self
    end

+    def warnings
+      return [] unless @root
+      @warnings ||= @root.warnings
+    end
+
    def registers
      @registers ||= {}
    end
@@ -172,7 +167,7 @@ module Liquid
        c = args.shift

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

        c
@@ -187,29 +182,34 @@ module Liquid
        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
      end

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

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

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

-      # Retrying a render resets resource usage
-      context.resource_limits.reset
-
      begin
        # render the nodelist.
        # for performance reasons we get an array back here. join will make a string out of it.
-        with_profiling(context) do
-          @root.render_to_output_buffer(context, output || '')
+        result = with_profiling do
+          @root.render(context)
        end
+        result.respond_to?(:join) ? result.join : result
      rescue Liquid::MemoryError => e
        context.handle_error(e)
      ensure
@@ -222,20 +222,34 @@ 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)
-      if @profiling && !context.partial
-        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
+    def calculate_line_numbers(raw_tokens)
+      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]
        @profiler = Profiler.new
        @profiler.start

@@ -248,13 +262,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/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,37 +0,0 @@
-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/utils.rb
+++ b/lib/liquid/utils.rb
@@ -1,24 +1,27 @@
 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.empty? ? [] : [collection]
-      end
-      return [] unless collection.respond_to?(:each)
+      return [collection] if non_blank_string?(collection)

      collection.each do |item|
+
        if to && to <= index
          break
        end
@@ -32,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
-        obj.strip =~ /\A-?\d+\.\d+\z/ ? 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'.freeze, 'today'.freeze
-        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,4 +1,5 @@
 module Liquid
+
  # Holds variables. Variables are only loaded "just in time"
  # and are not evaluated as part of the render stage
  #
@@ -10,23 +11,16 @@ module Liquid
  #   {{ user | link }}
  #
  class Variable
-    FilterMarkupRegex = /#{FilterSeparator}\s*(.*)/om
    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    FilterArgsRegex = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
-    JustTagAttributes = /\A#{TagAttributes}\z/o
-    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
-
-    attr_accessor :filters, :name, :line_number
-    attr_reader :parse_context
-    alias_method :options, :parse_context
-
+    EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
+    attr_accessor :filters, :name, :warnings
+    attr_accessor :line_number
    include ParserSwitching

-    def initialize(markup, parse_context)
+    def initialize(markup, options = {})
      @markup  = markup
      @name    = nil
-      @parse_context = parse_context
-      @line_number = parse_context.line_number
+      @options = options || {}

      parse_with_selected_parser(markup)
    end
@@ -41,27 +35,35 @@ module Liquid

    def lax_parse(markup)
      @filters = []
-      return unless markup =~ MarkupWithQuotedFragment
-
-      name_markup = Regexp.last_match(1)
-      filter_markup = Regexp.last_match(2)
-      @name = Expression.parse(name_markup)
-      if filter_markup =~ FilterMarkupRegex
-        filters = Regexp.last_match(1).scan(FilterParser)
-        filters.each do |f|
-          next unless f =~ /\w+/
-          filtername = Regexp.last_match(0)
-          filterargs = f.scan(FilterArgsRegex).flatten
-          @filters << parse_filter_expressions(filtername, filterargs)
+      if markup =~ /(#{QuotedFragment})(.*)/om
+        name_markup = $1
+        filter_markup = $2
+        @name = Expression.parse(name_markup)
+        if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
+          filters = $1.scan(FilterParser)
+          filters.each do |f|
+            if f =~ /\w+/
+              filtername = Regexp.last_match(0)
+              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)
+      # Very simple valid cases
+      if markup =~ EasyParse
+        @name = Expression.parse($1)
+        @filters = []
+        return
+      end
+
      @filters = []
      p = Parser.new(markup)
-
-      @name = Expression.parse(p.expression)
+      # Could be just filters with no input
+      @name = p.look(:pipe) ? nil : Expression.parse(p.expression)
      while p.consume?(:pipe)
        filtername = p.consume(:id)
        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
@@ -74,54 +76,38 @@ 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)
-      end
-
-      obj = context.apply_global_filter(obj)
-      taint_check(context, obj)
-      obj
-    end
-
-    def render_to_output_buffer(context, output)
-      obj = render(context)
-
-      if obj.is_a?(Array)
-        output << obj.join
-      elsif obj.nil?
-      else
-        output << obj.to_s
-      end
-
-      output
+        output = context.invoke(filter_name, output, *filter_args)
+      end.tap{ |obj| taint_check(obj) }
    end

    private

    def parse_filter_expressions(filter_name, unparsed_args)
      filter_args = []
-      keyword_args = nil
+      keyword_args = {}
      unparsed_args.each do |a|
-        if matches = a.match(JustTagAttributes)
-          keyword_args ||= {}
+        if matches = a.match(/\A#{TagAttributes}\z/o)
          keyword_args[matches[1]] = Expression.parse(matches[2])
        else
          filter_args << Expression.parse(a)
        end
      end
      result = [filter_name, filter_args]
-      result << keyword_args if keyword_args
+      result << keyword_args unless keyword_args.empty?
      result
    end

    def evaluate_filter_expressions(context, filter_args, filter_kwargs)
-      parsed_args = filter_args.map { |expr| context.evaluate(expr) }
+      parsed_args = filter_args.map{ |expr| context.evaluate(expr) }
      if filter_kwargs
        parsed_kwargs = {}
        filter_kwargs.each do |key, expr|
@@ -132,28 +118,17 @@ module Liquid
      parsed_args
    end

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

    def self.parse(markup)
      new(markup)
@@ -14,7 +12,7 @@ module Liquid

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

@@ -24,7 +22,7 @@ module Liquid
      @lookups.each_index do |i|
        lookup = lookups[i]
        if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse(Regexp.last_match(1))
+          lookups[i] = Expression.parse($1)
        elsif COMMAND_METHODS.include?(lookup)
          @command_flags |= 1 << i
        end
@@ -41,8 +39,8 @@ module Liquid
        # If object is a hash- or array-like object we look for the
        # presence of the key and if its available we return it
        if object.respond_to?(:[]) &&
-            ((object.respond_to?(:key?) && object.key?(key)) ||
-             (object.respond_to?(:fetch) && key.is_a?(Integer)))
+          ((object.respond_to?(: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
          res = context.lookup_and_evaluate(object, key)
@@ -55,11 +53,9 @@ module Liquid
          object = object.send(key).to_liquid

          # No key was present with the desired value and it wasn't one of the directly supported
-          # keywords either. The only thing we got left is to return nil or
-          # raise an exception if `strict_variables` option is set to true
+          # keywords either. The only thing we got left is to return nil
        else
-          return nil unless context.strict_variables
-          raise Liquid::UndefinedVariable, "undefined variable #{key}"
+          return nil
        end

        # If we are dealing with a drop here we have to
@@ -70,7 +66,7 @@ module Liquid
    end

    def ==(other)
-      self.class == other.class && state == other.state
+      self.class == other.class && self.state == other.state
    end

    protected
@@ -78,11 +74,5 @@ module Liquid
    def state
      [@name, @lookups, @command_flags]
    end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        @node.lookups
-      end
-    end
  end
 end
--- a/lib/liquid/version.rb
+++ b/lib/liquid/version.rb
@@ -1,5 +1,4 @@
 # encoding: utf-8
-
 module Liquid
-  VERSION = "4.0.3".freeze
+  VERSION = "3.0.0"
 end
--- a/liquid.gemspec
+++ b/liquid.gemspec
@@ -1,7 +1,6 @@
 # encoding: utf-8
-
 lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$:.unshift lib unless $:.include?(lib)

 require "liquid/version"

@@ -10,22 +9,21 @@ Gem::Specification.new do |s|
  s.version     = Liquid::VERSION
  s.platform    = Gem::Platform::RUBY
  s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
-  s.authors     = ["Tobias Lütke"]
+  s.authors     = ["Tobias Luetke"]
  s.email       = ["tobi@leetsoft.com"]
  s.homepage    = "http://www.liquidmarkup.org"
  s.license     = "MIT"
-  # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
+  #s.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.extra_rdoc_files  = ["History.md", "README.md"]

  s.require_path = "lib"

-  s.add_development_dependency('rake', '~> 11.3')
-  s.add_development_dependency('minitest')
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'minitest'
 end
--- a/performance/benchmark.rb
+++ b/performance/benchmark.rb
@@ -1,11 +1,11 @@
 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
@@ -13,6 +13,5 @@ Benchmark.ips do |x|
  puts

  x.report("parse:") { profiler.compile }
-  x.report("render:") { profiler.render }
-  x.report("parse & render:") { profiler.run }
+  x.report("parse & run:") { profiler.run }
 end
--- a/performance/memory_profile.rb
+++ b/performance/memory_profile.rb
@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-require 'benchmark/ips'
-require 'memory_profiler'
-require 'terminal-table'
-require_relative 'theme_runner'
-
-class Profiler
-  LOG_LABEL   = "Profiling: ".rjust(14).freeze
-  REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
-
-  def self.run
-    puts
-    yield new
-  end
-
-  def initialize
-    @allocated = []
-    @retained  = []
-    @headings  = []
-  end
-
-  def profile(phase, &block)
-    print LOG_LABEL
-    print "#{phase}.. ".ljust(10)
-    report = MemoryProfiler.report(&block)
-    puts 'Done.'
-    @headings  << phase.capitalize
-    @allocated << "#{report.scale_bytes(report.total_allocated_memsize)} (#{report.total_allocated} objects)"
-    @retained  << "#{report.scale_bytes(report.total_retained_memsize)} (#{report.total_retained} objects)"
-
-    return if ENV['CI']
-
-    require 'fileutils'
-    report_file = File.join(REPORTS_DIR, "#{sanitize(phase)}.txt")
-    FileUtils.mkdir_p(REPORTS_DIR)
-    report.pretty_print(to_file: report_file, scale_bytes: true)
-  end
-
-  def tabulate
-    table = Terminal::Table.new(headings: @headings.unshift('Phase')) do |t|
-      t << @allocated.unshift('Total allocated')
-      t << @retained.unshift('Total retained')
-    end
-
-    puts
-    puts table
-    puts "\nDetailed report(s) saved to #{REPORTS_DIR}/" unless ENV['CI']
-  end
-
-  def sanitize(string)
-    string.downcase.gsub(/[\W]/, '-').squeeze('-')
-  end
-end
-
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
-
-runner = ThemeRunner.new
-Profiler.run do |x|
-  x.profile('parse') { runner.compile }
-  x.profile('render') { runner.render }
-  x.tabulate
-end
--- a/performance/profile.rb
+++ b/performance/profile.rb
@@ -1,24 +1,17 @@
-require 'stackprof'
-require_relative 'theme_runner'
+require 'stackprof' rescue fail("install stackprof extension/gem")
+require File.dirname(__FILE__) + '/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
+    100.times do
      profiler.run
    end
  end
-
-  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
-    File.open(graph_filename, 'w') do |f|
-      StackProf::Report.new(results).print_graphviz(nil, f)
-    end
-  end
-
  StackProf::Report.new(results).print_text(false, 20)
  File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
 end
--- a/performance/shopify/comment_form.rb
+++ b/performance/shopify/comment_form.rb
@@ -5,14 +5,14 @@ class CommentForm < Liquid::Block
    super

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

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

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

  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
@@ -5,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|
@@ -16,10 +16,9 @@ module Database
      end

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

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

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

      db
@@ -40,7 +39,7 @@ module Database
  end
 end

-if __FILE__ == $PROGRAM_NAME
-  p(Database.tables['collections']['frontpage'].keys)
-  # p Database.tables['blog']['articles']
+if __FILE__ == $0
+  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,7 +1,9 @@
 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,19 +1,19 @@
-$LOAD_PATH.unshift(__dir__ + '/../../lib')
-require_relative '../../lib/liquid'
+$:.unshift File.dirname(__FILE__) + '/../../lib'
+require File.dirname(__FILE__) + '/../../lib/liquid'

-require_relative 'comment_form'
-require_relative 'paginate'
-require_relative 'json_filter'
-require_relative 'money_filter'
-require_relative 'shop_filter'
-require_relative 'tag_filter'
-require_relative 'weight_filter'
+require File.dirname(__FILE__) + '/comment_form'
+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'

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

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

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

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

  def initialize(tag_name, markup, options)
    super

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

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

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

      pagination = {
-        'page_size' => @page_size,
-        'current_page' => 5,
-        'current_offset' => @page_size * 5,
+        'page_size'      => @page_size,
+        'current_page'   => 5,
+        'current_offset' => @page_size * 5
      }

      context['paginate'] = pagination

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

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

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

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

      hellip_break = false

      if page_count > 2
-        1.upto(page_count - 1) do |page|
+        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
+          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
@@ -77,11 +78,11 @@ class Paginate < Liquid::Block
  private

  def no_link(title)
-    { 'title' => title, 'is_link' => false }
+    { 'title' => title, 'is_link' => false}
  end

  def link(title, page)
-    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true }
+    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true}
  end

  def current_url
--- a/performance/shopify/shop_filter.rb
+++ b/performance/shopify/shop_filter.rb
@@ -1,4 +1,5 @@
 module ShopFilter
+
  def asset_url(input)
    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
  end
@@ -15,16 +16,16 @@ module ShopFilter
    %(<script src="#{url}" type="text/javascript"></script>)
  end

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

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

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

  def link_to_vendor(vendor)
@@ -52,7 +53,8 @@ module ShopFilter
  end

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

@@ -60,24 +62,27 @@ module ShopFilter
    when 'original'
      return '/files/shops/random_number/' + url
    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
+      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"
    else
      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
    end
  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|
-      html << if part['is_link']
-        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+    for part in paginate['parts']
+
+      if part['is_link']
+        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
      elsif part['title'].to_i == paginate['current_page'].to_i
-        %(<span class="page current">#{part['title']}</span>)
+        html << %(<span class="page current">#{part['title']}</span>)
      else
-        %(<span class="deco">#{part['title']}</span>)
+        html << %(<span class="deco">#{part['title']}</span>)
      end
+
    end

    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
@@ -101,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,9 +1,10 @@
 module TagFilter
+
  def link_to_tag(label, tag)
    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
  end

-  def highlight_active_tag(tag, css_class = 'active')
+  def highlight_active_tag(tag, css_class='active')
    if @context['current_tags'].include?(tag)
      "<span class=\"#{css_class}\">#{tag}</span>"
    else
@@ -13,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,9 +1,11 @@
 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
@@ -6,115 +6,73 @@
 # 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_relative 'shopify/database'
+require File.dirname(__FILE__) + '/shopify/liquid'
+require File.dirname(__FILE__) + '/shopify/database.rb'

 class ThemeRunner
  class FileSystem
+
    def initialize(path)
      @path = path
    end

    # Called by Liquid to retrieve a template file
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
      File.read(@path + '/' + template_path + '.liquid')
    end
  end

-  # Initialize a new liquid ThemeRunner instance
-  # Will load all templates into memory, do this now so that we don't profile IO.
+  # Load all templates into memory, do this now so that
+  # we don't profile IO.
  def initialize
-    @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
+    @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),
-        layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
-        template_name: test,
-      }
+
+      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), 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|
-      Liquid::Template.new.parse(test_hash[:liquid])
-      Liquid::Template.new.parse(test_hash[:layout])
+    # Dup assigns because will make some changes to them
+
+    @tests.each do |liquid, layout, template_name|
+
+      tmpl = Liquid::Template.new
+      tmpl.parse(liquid)
+      tmpl = Liquid::Template.new
+      tmpl.parse(layout)
    end
  end

-  # `run` is called to benchmark rendering and compiling at the same time
-  def run
-    each_test do |liquid, layout, assigns, page_template, template_name|
-      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
+   def run
    # Dup assigns because will make some changes to them
    assigns = Database.tables.dup

-    @tests.each do |test_hash|
-      # Compute page_template outside of profiler run, uninteresting to profiler
-      page_template = File.basename(test_hash[:template_name], File.extname(test_hash[:template_name]))
-      yield(test_hash[:liquid], test_hash[:layout], assigns, page_template, test_hash[:template_name])
+    @tests.each do |liquid, layout, template_name|
+
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      page_template = File.basename(template_name, File.extname(template_name))
+      compile_and_render(liquid, layout, assigns, page_template, template_name)
+
    end
  end

-  # 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
@@ -3,36 +3,26 @@ require 'test_helper'
 class AssignTest < Minitest::Test
  include Liquid

-  def test_assign_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% assign this-thing = 'Print this-thing' %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
  def test_assigned_variable
    assert_template_result('.foo.',
-      '{% assign foo = values %}.{{ foo[0] }}.',
-      'values' => %w(foo bar baz))
+                           '{% assign foo = values %}.{{ foo[0] }}.',
+                           'values' => %w{foo bar baz})

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

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

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

  def test_assign_uses_error_mode
--- a/test/integration/blank_test.rb
+++ b/test/integration/blank_test.rb
@@ -1,14 +1,15 @@
 require 'test_helper'

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

 class BlankTestFileSystem
-  def read_template_file(template_path)
+  def read_template_file(template_path, context)
    template_path
  end
 end
@@ -30,9 +31,7 @@ class BlankTest < Minitest::Test
  end

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

  def test_loops_are_blank
@@ -48,7 +47,7 @@ class BlankTest < Minitest::Test
  end

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

  def test_comments_are_blank
@@ -61,9 +60,9 @@ 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 %}
-      {% if true %} but this is not {% endif %}'))
+    assert_template_result("\n       but this is not "*(N+1),
+      wrap(%q{{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
+      {% if true %} but this is not {% endif %}}))
  end

  def test_assigns_are_blank
@@ -77,31 +76,31 @@ class BlankTest < Minitest::Test

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

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

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

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

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

  def test_case_is_blank
    assert_template_result("", wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
    assert_template_result("", wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
-    assert_template_result("   x  " * (N + 1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
+    assert_template_result("   x  "*(N+1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
  end
 end
--- a/test/integration/block_test.rb
+++ b/test/integration/block_test.rb
@@ -1,12 +0,0 @@
-require 'test_helper'
-
-class BlockTest < Minitest::Test
-  include Liquid
-
-  def test_unexpected_end_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% if true %}{% endunless %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif"
-  end
-end
--- a/test/integration/capture_test.rb
+++ b/test/integration/capture_test.rb
@@ -7,16 +7,6 @@ class CaptureTest < Minitest::Test
    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
  end

-  def test_capture_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% capture this-thing %}Print this-thing{% endcapture %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
  def test_capture_to_variable_from_outer_scope_if_existing
    template_source = <<-END_TEMPLATE
    {% assign var = '' %}
--- a/test/integration/context_test.rb
+++ b/test/integration/context_test.rb
@@ -18,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,19 +0,0 @@
-require 'test_helper'
-
-class DocumentTest < Minitest::Test
-  include Liquid
-
-  def test_unexpected_outer_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% else %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
-  end
-
-  def test_unknown_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% foo %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
-  end
-end
--- a/test/integration/drop_test.rb
+++ b/test/integration/drop_test.rb
@@ -13,12 +13,13 @@ class ContextDrop < Liquid::Drop
    @context['forloop.index']
  end

-  def liquid_method_missing(method)
-    @context[method]
+  def before_method(method)
+    return @context[method]
  end
 end

 class ProductDrop < Liquid::Drop
+
  class TextDrop < Liquid::Drop
    def array
      ['text1', 'text2']
@@ -30,8 +31,8 @@ class ProductDrop < Liquid::Drop
  end

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

@@ -52,14 +53,13 @@ class ProductDrop < Liquid::Drop
  end

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

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

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

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

@@ -124,10 +124,8 @@ class DropsTest < Minitest::Test
  def test_rendering_warns_on_tainted_attr
    with_taint_mode(:warn) do
      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      context = Context.new('product' => ProductDrop.new)
-      tpl.render!(context)
-      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
-      assert_equal "variable 'product.user_input' is tainted and was not escaped", context.warnings.first.to_s(false)
+      tpl.render!('product' => ProductDrop.new)
+      assert_match /tainted/, tpl.warnings.first
    end
  end

@@ -153,37 +151,37 @@ class DropsTest < Minitest::Test
  end

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

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

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

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

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

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

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

@@ -195,43 +193,43 @@ class DropsTest < Minitest::Test
  end

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

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

  def test_scope_with_assigns
-    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
-    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
-    assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{{a}}'  ).render!('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse( '{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal 'test', Liquid::Template.parse( '{% assign header_gif = "test"%}{{header_gif}}'  ).render!('context' => ContextDrop.new)
+    assert_equal 'test', Liquid::Template.parse( "{% assign header_gif = 'test'%}{{header_gif}}"  ).render!('context' => ContextDrop.new)
  end

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

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

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

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

-  def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
+  def test_enumerable_drop_will_invoke_before_method_for_clashing_method_names
    ["select", "each", "map", "cycle"].each do |method|
      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
@@ -241,7 +239,7 @@ class DropsTest < Minitest::Test
  end

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

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

-    [:min, :first].each do |method|
+    [ :min, :first ].each do |method|
      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
--- a/test/integration/error_handling_test.rb
+++ b/test/integration/error_handling_test.rb
@@ -1,5 +1,24 @@
 require 'test_helper'

+class ErrorDrop < Liquid::Drop
+  def standard_error
+    raise Liquid::StandardError, 'standard error'
+  end
+
+  def argument_error
+    raise Liquid::ArgumentError, 'argument error'
+  end
+
+  def syntax_error
+    raise Liquid::SyntaxError, 'syntax error'
+  end
+
+  def exception
+    raise Exception, 'exception'
+  end
+
+end
+
 class ErrorHandlingTest < Minitest::Test
  include Liquid

@@ -37,7 +56,7 @@ class ErrorHandlingTest < Minitest::Test
  end

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

    assert_equal 1, template.errors.size
@@ -45,7 +64,7 @@ class ErrorHandlingTest < Minitest::Test
  end

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

    assert_equal 1, template.errors.size
@@ -53,7 +72,7 @@ class ErrorHandlingTest < Minitest::Test
  end

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

    assert_equal 1, template.errors.size
@@ -75,7 +94,7 @@ class ErrorHandlingTest < Minitest::Test
  end

  def test_lax_unrecognized_operator
-    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
+    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
    assert_equal ' Liquid error: Unknown operator =! ', template.render
    assert_equal 1, template.errors.size
    assert_equal Liquid::ArgumentError, template.errors.first.class
@@ -83,44 +102,31 @@ class ErrorHandlingTest < Minitest::Test

  def test_with_line_numbers_adds_numbers_to_parser_errors
    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
+      template = Liquid::Template.parse(%q{
          foobar

          {% "cat" | foobar %}

          bla
-        ',
-        line_numbers: true)
+        },
+        :line_numbers => true
+      )
    end

-    assert_match(/Liquid syntax error \(line 4\)/, err.message)
-  end
-
-  def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
-          foobar
-
-          {%- "cat" | foobar -%}
-
-          bla
-        ',
-        line_numbers: true)
-    end
-
-    assert_match(/Liquid syntax error \(line 4\)/, err.message)
+    assert_match /Liquid syntax error \(line 4\)/, err.message
  end

  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
-    template = Liquid::Template.parse('
+    template = Liquid::Template.parse(%q{
        foobar

        {% if 1 =! 2 %}ok{% endif %}

        bla
-            ',
-      error_mode: :warn,
-      line_numbers: true)
+      },
+      :error_mode => :warn,
+      :line_numbers => true
+    )

    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
      template.warnings.map(&:message)
@@ -128,15 +134,16 @@ class ErrorHandlingTest < Minitest::Test

  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
+      Liquid::Template.parse(%q{
          foobar

          {% if 1 =! 2 %}ok{% endif %}

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

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

  def test_syntax_errors_in_nested_blocks_have_correct_line_number
    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
+      Liquid::Template.parse(%q{
          foobar

          {% if 1 != 2 %}
@@ -152,8 +159,9 @@ class ErrorHandlingTest < Minitest::Test
          {% endif %}

          bla
-                ',
-        line_numbers: true)
+        },
+        :line_numbers => true
+      )
    end

    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
@@ -161,18 +169,18 @@ class ErrorHandlingTest < Minitest::Test

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

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

  def test_warnings
-    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
+    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', :error_mode => :warn)
    assert_equal 3, template.warnings.size
    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
@@ -181,12 +189,12 @@ class ErrorHandlingTest < Minitest::Test
  end

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

  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
@@ -196,60 +204,4 @@ class ErrorHandlingTest < Minitest::Test
      template.render('errors' => ErrorDrop.new)
    end
  end
-
-  def test_default_exception_renderer_with_internal_error
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-
-    output = template.render('errors' => ErrorDrop.new)
-
-    assert_equal 'This is a runtime error: Liquid error (line 1): internal', output
-    assert_equal [Liquid::InternalError], template.errors.map(&:class)
-  end
-
-  def test_setting_default_exception_renderer
-    old_exception_renderer = Liquid::Template.default_exception_renderer
-    exceptions = []
-    Liquid::Template.default_exception_renderer = ->(e) { exceptions << e; '' }
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')
-
-    output = template.render('errors' => ErrorDrop.new)
-
-    assert_equal 'This is a runtime error: ', output
-    assert_equal [Liquid::ArgumentError], template.errors.map(&:class)
-  ensure
-    Liquid::Template.default_exception_renderer = old_exception_renderer if old_exception_renderer
-  end
-
-  def test_exception_renderer_exposing_non_liquid_error
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-    exceptions = []
-    handler = ->(e) { exceptions << e; e.cause }
-
-    output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
-
-    assert_equal 'This is a runtime error: runtime error', output
-    assert_equal [Liquid::InternalError], exceptions.map(&:class)
-    assert_equal exceptions, template.errors
-    assert_equal '#<RuntimeError: runtime error>', exceptions.first.cause.inspect
-  end
-
-  class TestFileSystem
-    def read_template_file(_template_path)
-      "{{ errors.argument_error }}"
-    end
-  end
-
-  def test_included_template_name_with_line_numbers
-    old_file_system = Liquid::Template.file_system
-
-    begin
-      Liquid::Template.file_system = TestFileSystem.new
-      template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
-      page = template.render('errors' => ErrorDrop.new)
-    ensure
-      Liquid::Template.file_system = old_file_system
-    end
-    assert_equal "Argument error:\nLiquid error (product line 1): argument error", page
-    assert_equal "product", template.errors.first.template_name
-  end
 end
--- a/test/integration/filter_test.rb
+++ b/test/integration/filter_test.rb
@@ -2,35 +2,29 @@ require 'test_helper'

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

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

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

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

 class FiltersTest < Minitest::Test
  include Liquid

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

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

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

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

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

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

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

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

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

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

-    assert_equal '1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context)
-    assert_equal 'alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context)
-    assert_equal '3', Template.parse("{{value | sort}}").render(@context)
-    assert_equal 'are flower', Template.parse("{{arrays | sort | join}}").render(@context)
-    assert_equal 'Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context)
-  end
-
-  def test_sort_natural
-    @context['words'] = ['case', 'Assert', 'Insensitive']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
-    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
-
-    # Test strings
-    assert_equal 'Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context)
-
-    # Test hashes
-    assert_equal 'A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context)
-
-    # Test objects
-    assert_equal 'A b C', Template.parse("{{objects | sort_natural: 'a' | map: 'a' | join}}").render(@context)
-  end
-
-  def test_compact
-    @context['words'] = ['a', nil, 'b', nil, 'c']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
-    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
-
-    # Test strings
-    assert_equal 'a b c', Template.parse("{{words | compact | join}}").render(@context)
-
-    # Test hashes
-    assert_equal 'A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context)
-
-    # Test objects
-    assert_equal 'A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context)
+    assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
+    assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
+    assert_equal [3], Variable.new("value | sort").render(@context)
+    assert_equal ['are', 'flower'], Variable.new("arrays | sort").render(@context)
  end

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

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

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

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

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

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

  def test_nonexistent_filter_is_ignored
    @context['var'] = 1000

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

  def test_filter_with_keyword_arguments
    @context['surname'] = 'john'
-    @context['input'] = 'hello %{first_name}, %{last_name}'
    @context.add_filters(SubstituteFilter)
-    output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
+    output = Variable.new(%! 'hello %{first_name}, %{last_name}' | substitute: first_name: surname, last_name: 'doe' !).render(@context)
    assert_equal 'hello john, doe', output
  end
-
-  def test_override_object_method_in_filter
-    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
-
-    # tap still treated as a non-existent filter
-    assert_equal "1000", Template.parse("{{var | tap}}").render!('var' => 1000)
-  end
 end

 class FiltersInTemplate < Minitest::Test
@@ -159,8 +113,8 @@ class FiltersInTemplate < Minitest::Test
  def test_local_global
    with_global_filter(MoneyFilter) do
      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: CanadianMoneyFilter)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: [CanadianMoneyFilter])
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
    end
  end

@@ -169,10 +123,3 @@ class FiltersInTemplate < Minitest::Test
    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
  end
 end # FiltersTest
-
-class TestObject < Liquid::Drop
-  attr_accessor :a
-  def initialize(a)
-    @a = a
-  end
-end
--- a/test/integration/hash_ordering_test.rb
+++ b/test/integration/hash_ordering_test.rb
@@ -1,18 +1,18 @@
 require 'test_helper'

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

  def test_global_register_order
--- a/test/integration/output_test.rb
+++ b/test/integration/output_test.rb
@@ -1,7 +1,7 @@
 require 'test_helper'

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

@@ -14,7 +14,7 @@ module FunnyFilter
  end

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

  def paragraph(input)
@@ -22,8 +22,9 @@ module FunnyFilter
  end

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

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

  def test_variable
-    text = %( {{best_cars}} )
+    text = %| {{best_cars}} |

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -62,25 +59,25 @@ class ParsingQuirksTest < Minitest::Test
  end

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

  def test_meaningless_parens_lax
    with_error_mode(:lax) do
-      assigns = { 'b' => 'bar', 'c' => 'baz' }
+      assigns = {'b' => 'bar', 'c' => 'baz'}
      markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
+      assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}", assigns)
    end
  end

  def test_unexpected_characters_silently_eat_logic_lax
    with_error_mode(:lax) do
      markup = "true && false"
-      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
+      assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}")
      markup = "false || true"
-      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
+      assert_template_result('',"{% if #{markup} %} YES {% endif %}")
    end
  end

@@ -92,31 +89,15 @@ class ParsingQuirksTest < Minitest::Test

  def test_unanchored_filter_arguments
    with_error_mode(:lax) do
-      assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
+      assert_template_result('hi',"{{ 'hi there' | split$$$:' ' | first }}")

      assert_template_result('x', "{{ 'X' | downcase) }}")

      # After the messed up quotes a filter without parameters (reverse) should work
      # but one with parameters (remove) shouldn't be detected.
      assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
-      assert_template_result('hi ', "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
+      assert_template_result('hi ',  "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
    end
  end

-  def test_invalid_variables_work
-    with_error_mode(:lax) do
-      assert_template_result('bar', "{% assign 123foo = 'bar' %}{{ 123foo }}")
-      assert_template_result('123', "{% assign 123 = 'bar' %}{{ 123 }}")
-    end
-  end
-
-  def test_extra_dots_in_ranges
-    with_error_mode(:lax) do
-      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
-    end
-  end
-
-  def test_contains_in_id
-    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
-  end
 end # ParsingQuirksTest
--- a/test/integration/render_profiling_test.rb
+++ b/test/integration/render_profiling_test.rb
@@ -4,7 +4,7 @@ class RenderProfilingTest < Minitest::Test
  include Liquid

  class ProfilingFileSystem
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
      "Rendering template {% assign template_name = '#{template_path}'%}\n{{ template_name }}"
    end
  end
@@ -21,7 +21,7 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_parse_makes_available_simple_profiling
-    t = Template.parse("{{ 'a string' | upcase }}", profile: true)
+    t = Template.parse("{{ 'a string' | upcase }}", :profile => true)
    t.render!

    assert_equal 1, t.profiler.length
@@ -31,14 +31,14 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_render_ignores_raw_strings_when_profiling
-    t = Template.parse("This is raw string\nstuff\nNewline", profile: true)
+    t = Template.parse("This is raw string\nstuff\nNewline", :profile => true)
    t.render!

    assert_equal 0, t.profiler.length
  end

  def test_profiling_includes_line_numbers_of_liquid_nodes
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
    t.render!
    assert_equal 2, t.profiler.length

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

  def test_profiling_includes_line_numbers_of_included_partials
-    t = Template.parse("{% include 'a_template' %}", profile: true)
+    t = Template.parse("{% include 'a_template' %}", :profile => true)
    t.render!

    included_children = t.profiler[0].children
@@ -61,7 +61,7 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_profiling_times_the_rendering_of_tokens
-    t = Template.parse("{% include 'a_template' %}", profile: true)
+    t = Template.parse("{% include 'a_template' %}", :profile => true)
    t.render!

    node = t.profiler[0]
@@ -69,14 +69,14 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_profiling_times_the_entire_render
-    t = Template.parse("{% include 'a_template' %}", profile: true)
+    t = Template.parse("{% include 'a_template' %}", :profile => true)
    t.render!

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

  def test_profiling_uses_include_to_mark_children
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
    t.render!

    include_node = t.profiler[1]
@@ -84,7 +84,7 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_profiling_marks_children_with_the_name_of_included_partial
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
    t.render!

    include_node = t.profiler[1]
@@ -94,7 +94,7 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_profiling_supports_multiple_templates
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", profile: true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", :profile => true)
    t.render!

    a_template = t.profiler[1]
@@ -109,7 +109,7 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_profiling_supports_rendering_the_same_partial_multiple_times
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", profile: true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", :profile => true)
    t.render!

    a_template1 = t.profiler[1]
@@ -124,11 +124,11 @@ class RenderProfilingTest < Minitest::Test
  end

  def test_can_iterate_over_each_profiling_entry
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
    t.render!

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

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

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

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

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

    assert_equal 1, t.profiler.length
    # Will profile each invocation of the for block
--- a/test/integration/security_test.rb
+++ b/test/integration/security_test.rb
@@ -9,36 +9,34 @@ end
 class SecurityTest < Minitest::Test
  include Liquid

-  def setup
-    @assigns = {}
-  end
-
  def test_no_instance_eval
    text = %( {{ '1+1' | instance_eval }} )
-    expected = %( 1+1 )
+    expected = %| 1+1 |

    assert_equal expected, Template.parse(text).render!(@assigns)
  end

  def test_no_existing_instance_eval
    text = %( {{ '1+1' | __instance_eval__ }} )
-    expected = %( 1+1 )
+    expected = %| 1+1 |

    assert_equal expected, Template.parse(text).render!(@assigns)
  end

+
  def test_no_instance_eval_after_mixing_in_new_filter
    text = %( {{ '1+1' | instance_eval }} )
-    expected = %( 1+1 )
+    expected = %| 1+1 |

    assert_equal expected, Template.parse(text).render!(@assigns)
  end

+
  def test_no_instance_eval_later_in_chain
    text = %( {{ '1+1' | add_one | instance_eval }} )
-    expected = %( 1+1 + 1 )
+    expected = %| 1+1 + 1 |

-    assert_equal expected, Template.parse(text).render!(@assigns, filters: SecurityFilter)
+    assert_equal expected, Template.parse(text).render!(@assigns, :filters => SecurityFilter)
  end

  def test_does_not_add_filters_to_symbol_table
@@ -63,18 +61,4 @@ class SecurityTest < Minitest::Test

    assert_equal [], (Symbol.all_symbols - current_symbols)
  end
-
-  def test_max_depth_nested_blocks_does_not_raise_exception
-    depth = Liquid::Block::MAX_DEPTH
-    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
-    assert_equal "rendered", Template.parse(code).render!
-  end
-
-  def test_more_than_max_depth_nested_blocks_raises_exception
-    depth = Liquid::Block::MAX_DEPTH + 1
-    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
-    assert_raises(Liquid::StackLevelError) do
-      Template.parse(code).render!
-    end
-  end
 end # SecurityTest
--- a/test/integration/standard_filter_test.rb
+++ b/test/integration/standard_filter_test.rb
@@ -17,7 +17,7 @@ class TestThing
    "woot: #{@foo}"
  end

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

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

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

@@ -59,7 +49,7 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_size
-    assert_equal 3, @filters.size([1, 2, 3])
+    assert_equal 3, @filters.size([1,2,3])
    assert_equal 0, @filters.size([])
    assert_equal 0, @filters.size(nil)
  end
@@ -86,27 +76,20 @@ class StandardFiltersTest < Minitest::Test
    assert_equal '', @filters.slice(nil, 0)
    assert_equal '', @filters.slice('foobar', 100, 10)
    assert_equal '', @filters.slice('foobar', -100, 10)
-    assert_equal 'oob', @filters.slice('foobar', '1', '3')
-    assert_raises(Liquid::ArgumentError) do
-      @filters.slice('foobar', nil)
-    end
-    assert_raises(Liquid::ArgumentError) do
-      @filters.slice('foobar', 0, "")
-    end
  end

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

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

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

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

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

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

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

  def test_strip_html
@@ -181,191 +139,48 @@ class StandardFiltersTest < Minitest::Test
    assert_equal 'test', @filters.strip_html("<div\nclass='multiline'>test</div>")
    assert_equal 'test', @filters.strip_html("<!-- foo bar \n test -->test")
    assert_equal '', @filters.strip_html(nil)
-
-    # Quirk of the existing implementation
-    assert_equal 'foo;', @filters.strip_html("<<<script </script>script>foo;</script>")
  end

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

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

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

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

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

-  def test_uniq_empty_array
-    assert_equal [], @filters.uniq([], "a")
-  end
-
-  def test_uniq_invalid_property
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-
-    assert_raises Liquid::ArgumentError do
-      @filters.uniq(foo, "bar")
-    end
-  end
-
-  def test_compact_empty_array
-    assert_equal [], @filters.compact([], "a")
-  end
-
-  def test_compact_invalid_property
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-
-    assert_raises Liquid::ArgumentError do
-      @filters.compact(foo, "bar")
-    end
-  end
-
  def test_reverse
-    assert_equal [4, 3, 2, 1], @filters.reverse([1, 2, 3, 4])
+    assert_equal [4,3,2,1], @filters.reverse([1,2,3,4])
  end

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

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

  def test_map_doesnt_call_arbitrary_stuff
@@ -380,7 +195,7 @@ class StandardFiltersTest < Minitest::Test

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

  def test_legacy_map_on_hashes_with_dynamic_key
@@ -397,51 +212,15 @@ class StandardFiltersTest < Minitest::Test

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

-  def test_map_over_drops_returning_procs
-    drops = [
-      {
-        "proc" => -> { "foo" },
-      },
-      {
-        "proc" => -> { "bar" },
-      },
-    ]
-    templ = '{{ drops | map: "proc" }}'
-    assert_template_result "foobar", templ, "drops" => drops
-  end
-
  def test_map_works_on_enumerables
    assert_template_result "123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new
  end

-  def test_map_returns_empty_on_2d_input_array
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-
-    assert_raises Liquid::ArgumentError do
-      @filters.map(foo, "bar")
-    end
-  end
-
-  def test_map_returns_empty_with_no_property
-    foo = [
-      [1],
-      [2],
-      [3],
-    ]
-    assert_raises Liquid::ArgumentError do
-      @filters.map(foo, nil)
-    end
-  end
-
  def test_sort_works_on_enumerables
    assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
  end
@@ -451,10 +230,6 @@ class StandardFiltersTest < Minitest::Test
    assert_template_result 'foobar', '{{ foo | last }}', 'foo' => [ThingWithToLiquid.new]
  end

-  def test_truncate_calls_to_liquid
-    assert_template_result "wo...", '{{ foo | truncate: 5 }}', "foo" => TestThing.new
-  end
-
  def test_date
    assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
    assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
@@ -472,40 +247,31 @@ class StandardFiltersTest < Minitest::Test
    assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")

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

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

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

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

  def test_replace
    assert_equal '2 2 2 2', @filters.replace('1 1 1 1', '1', 2)
-    assert_equal '2 2 2 2', @filters.replace('1 1 1 1', 1, 2)
    assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', '1', 2)
-    assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', 1, 2)
    assert_template_result '2 1 1 1', "{{ '1 1 1 1' | replace_first: '1', 2 }}"
  end

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

@@ -540,38 +306,20 @@ class StandardFiltersTest < Minitest::Test
  def test_plus
    assert_template_result "2", "{{ 1 | plus:1 }}"
    assert_template_result "2.0", "{{ '1' | plus:'1.0' }}"
-
-    assert_template_result "5", "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3)
  end

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

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

  def test_divided_by
@@ -582,96 +330,38 @@ class StandardFiltersTest < Minitest::Test
    assert_equal "Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render

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

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

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

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

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

  def test_append
-    assigns = { 'a' => 'bc', 'b' => 'd' }
-    assert_template_result('bcd', "{{ a | append: 'd'}}", assigns)
-    assert_template_result('bcd', "{{ a | append: b}}", assigns)
-  end
-
-  def test_concat
-    assert_equal [1, 2, 3, 4], @filters.concat([1, 2], [3, 4])
-    assert_equal [1, 2, 'a'],  @filters.concat([1, 2], ['a'])
-    assert_equal [1, 2, 10],   @filters.concat([1, 2], [10])
-
-    assert_raises(Liquid::ArgumentError, "concat filter requires an array argument") do
-      @filters.concat([1, 2], 10)
-    end
+    assigns = {'a' => 'bc', 'b' => 'd' }
+    assert_template_result('bcd',"{{ a | append: 'd'}}",assigns)
+    assert_template_result('bcd',"{{ a | append: b}}",assigns)
  end

  def test_prepend
-    assigns = { 'a' => 'bc', 'b' => 'a' }
-    assert_template_result('abc', "{{ a | prepend: 'a'}}", assigns)
-    assert_template_result('abc', "{{ a | prepend: b}}", assigns)
+    assigns = {'a' => 'bc', 'b' => 'a' }
+    assert_template_result('abc',"{{ a | prepend: 'a'}}",assigns)
+    assert_template_result('abc',"{{ a | prepend: b}}",assigns)
  end

  def test_default
@@ -684,93 +374,6 @@ class StandardFiltersTest < Minitest::Test
  end

  def test_cannot_access_private_methods
-    assert_template_result('a', "{{ 'a' | to_number }}")
-  end
-
-  def test_date_raises_nothing
-    assert_template_result('', "{{ '' | date: '%D' }}")
-    assert_template_result('abc', "{{ 'abc' | date: '%D' }}")
-  end
-
-  def test_where
-    input = [
-      { "handle" => "alpha", "ok" => true },
-      { "handle" => "beta", "ok" => false },
-      { "handle" => "gamma", "ok" => false },
-      { "handle" => "delta", "ok" => true },
-    ]
-
-    expectation = [
-      { "handle" => "alpha", "ok" => true },
-      { "handle" => "delta", "ok" => true },
-    ]
-
-    assert_equal expectation, @filters.where(input, "ok", true)
-    assert_equal expectation, @filters.where(input, "ok")
-  end
-
-  def test_where_no_key_set
-    input = [
-      { "handle" => "alpha", "ok" => true },
-      { "handle" => "beta" },
-      { "handle" => "gamma" },
-      { "handle" => "delta", "ok" => true },
-    ]
-
-    expectation = [
-      { "handle" => "alpha", "ok" => true },
-      { "handle" => "delta", "ok" => true },
-    ]
-
-    assert_equal expectation, @filters.where(input, "ok", true)
-    assert_equal expectation, @filters.where(input, "ok")
-  end
-
-  def test_where_non_array_map_input
-    assert_equal [{ "a" => "ok" }], @filters.where({ "a" => "ok" }, "a", "ok")
-    assert_equal [], @filters.where({ "a" => "not ok" }, "a", "ok")
-  end
-
-  def test_where_indexable_but_non_map_value
-    assert_raises(Liquid::ArgumentError) { @filters.where(1, "ok", true) }
-    assert_raises(Liquid::ArgumentError) { @filters.where(1, "ok") }
-  end
-
-  def test_where_non_boolean_value
-    input = [
-      { "message" => "Bonjour!", "language" => "French" },
-      { "message" => "Hello!", "language" => "English" },
-      { "message" => "Hallo!", "language" => "German" },
-    ]
-
-    assert_equal [{ "message" => "Bonjour!", "language" => "French" }], @filters.where(input, "language", "French")
-    assert_equal [{ "message" => "Hallo!", "language" => "German" }], @filters.where(input, "language", "German")
-    assert_equal [{ "message" => "Hello!", "language" => "English" }], @filters.where(input, "language", "English")
-  end
-
-  def test_where_array_of_only_unindexable_values
-    assert_nil @filters.where([nil], "ok", true)
-    assert_nil @filters.where([nil], "ok")
-  end
-
-  def test_where_no_target_value
-    input = [
-      { "foo" => false },
-      { "foo" => true },
-      { "foo" => "for sure" },
-      { "bar" => true },
-    ]
-
-    assert_equal [{ "foo" => true }, { "foo" => "for sure" }], @filters.where(input, "foo")
-  end
-
-  private
-
-  def with_timezone(tz)
-    old_tz = ENV['TZ']
-    ENV['TZ'] = tz
-    yield
-  ensure
-    ENV['TZ'] = old_tz
+    assert_template_result('a',"{{ 'a' | to_number }}")
  end
 end # StandardFiltersTest
--- a/Show More
+++ b/Show More