Fix echo tag

* Resolve InputIterator dropping context

* Prefer attr_reader

.github/probots.yml

@@ -0,0 +1,2 @@
+enabled:
+  - cla

.gitignore

@@ -6,3 +6,5 @@ pkg
 .rvmrc
 .ruby-version
 Gemfile.lock
+.bundle
+.byebug_history

.rubocop.yml

@@ -0,0 +1,17 @@
+inherit_from:
+  - 'https://shopify.github.io/ruby-style-guide/rubocop.yml'
+  - .rubocop_todo.yml
+
+require: rubocop-performance
+
+Performance:
+  Enabled: true
+
+AllCops:
+  TargetRubyVersion: 2.4
+  Exclude:
+    - 'vendor/bundle/**/*'
+
+Naming/MethodName:
+  Exclude:
+    - 'example/server/liquid_servlet.rb'

.rubocop_todo.yml

@@ -0,0 +1,48 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2019-09-11 06:34:25 +1000 using RuboCop version 0.74.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 2
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: runtime_error, standard_error
+Lint/InheritException:
+  Exclude:
+    - 'lib/liquid/interrupts.rb'
+
+# Offense count: 98
+# Cop supports --auto-correct.
+# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+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'

.travis.yml

@@ -1,16 +1,26 @@
-rvm:
+language: ruby
-  - 1.9
+cache: bundler
-  - 2.0
-  - 2.1
-  - jruby-19mode
-  - jruby-head
-  - rbx-2
-matrix:
-  allow_failures:
-    - rvm: rbx-2
-    - rvm: jruby-head
 
-script: "rake test"
+rvm:
+  - 2.4
+  - 2.5
+  - &latest_ruby 2.6
+  - 2.7
+  - ruby-head
+
+matrix:
+  include:
+    - rvm: *latest_ruby
+      script: bundle exec rake memory_profile:run
+      name: Profiling Memory Usage
+  allow_failures:
+    - rvm: ruby-head
+
+branches:
+  only:
+    - master
+    - gh-pages
+    - /.*-stable/
 
 notifications:
   disable: true

CONTRIBUTING.md

@@ -4,23 +4,22 @@
 
 * Bugfixes
 * Performance improvements
-* Features which are likely to be useful to the majority of Liquid users
+* Features that are likely to be useful to the majority of Liquid users
 
 ## Things we won't merge
 
-* Code which introduces considerable performance degrations
+* Code that introduces considerable performance degrations
-* Code which touches performance critical parts of Liquid and comes without benchmarks
+* Code that 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 that 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)
+* Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
-* Code which comes without tests
+* Code that does not include tests
-* Code which breaks existing tests
+* Code that 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 run a performance benchmark
+* If it makes sense, add tests for your code and/or run a performance benchmark
-* Make sure all tests pass
+* Make sure all tests pass (`bundle exec rake`)
 * 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.
 

Gemfile

@@ -1,8 +1,27 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
+git_source(:github) do |repo_name|
+  "https://github.com/#{repo_name}.git"
+end
 
 gemspec
-gem 'stackprof', platforms: :mri_21
+
+group :benchmark, :test do
+  gem 'benchmark-ips'
+  gem 'memory_profiler'
+  gem 'terminal-table'
+
+  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
+    gem 'stackprof'
+  end
+end
 
 group :test do
-  gem 'spy', '0.4.1'
+  gem 'rubocop', '~> 0.74.0', require: false
+  gem 'rubocop-performance', require: false
+
+  platform :mri, :truffleruby do
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
+  end
 end

History.md

@@ -1,67 +1,208 @@
-# Liquid Version History
+# Liquid Change Log
 
-## 3.0.0 / not yet released / branch "master"
+## 4.0.3 / 2019-03-12
 
-* ...
+### Fixed
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
+* Fix break and continue tags inside included templates in loops (#1072) [Justin Li]
-* 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]
 
-## 2.6.0 / 2013-11-25 / branch "2.6-stable"
+## 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
+
+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]
+
+## 2.6.0 / 2013-11-25
 
 IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains explicit Ruby 1.8 compatability.
 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, joliss]
+* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss]
-* Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]
+* 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, ndwebgroup]
+* 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, fw42]
+* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten]
-* Bugfix for #204: 'raw' parsing bug [Florian Weingarten, fw42]
+* Bugfix for #204: 'raw' parsing bug [Florian Weingarten]
-* Bugfix for #150: 'for' parsing bug [Peter Schröder, phoet]
+* Bugfix for #150: 'for' parsing bug [Peter Schröder]
-* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder, phoet]
+* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder]
-* Bugfix for #174, "can't convert Fixnum into String" for "replace" [wǒ_is神仙, jsw0528]
+* Bugfix for #174, "can't convert Fixnum into String" for "replace" [jsw0528]
-* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep, darkhelmet]
+* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep]
-* Resource limits [Florian Weingarten, fw42]
+* Resource limits [Florian Weingarten]
-* Add reverse filter [Jay Strybis, unreal]
+* Add reverse filter [Jay Strybis]
 * Add utf-8 support
-* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos, astathopoulos]
+* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos]
-* Cache tokenized partial templates [Tom Burns, boourns]
+* Cache tokenized partial templates [Tom Burns]
-* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer, stomar]
+* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer]
-* Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
+* Better documentation for 'include' tag (closes #163) [Peter Schröder]
-* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]
+* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves]
 
-## 2.5.4 / 2013-11-11 / branch "2.5-stable"
+## 2.5.5 / 2014-01-10 / branch "2-5-stable"
 
-* Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]
+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]
+
+## 2.5.4 / 2013-11-11
+
+* Fix "can't convert Fixnum into String" for "replace" (#173), [jsw0528]
 
 ## 2.5.3 / 2013-10-09
 
-* #232, #234, #237: Fix map filter bugs [Florian Weingarten, fw42]
+* #232, #234, #237: Fix map filter bugs [Florian Weingarten]
 
 ## 2.5.2 / 2013-09-03 / deleted
 
@@ -69,7 +210,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, fw42]
+* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten]
 
 ## 2.5.0 / 2013-03-06
 

README.md

@@ -1,5 +1,5 @@
-[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png?branch=master)](http://travis-ci.org/Shopify/liquid)
+[![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.png)](http://inch-ci.org/github/Shopify/liquid)
+[![Inline docs](http://inch-ci.org/github/Shopify/liquid.svg?branch=master)](http://inch-ci.org/github/Shopify/liquid)
 
 # Liquid template engine
 
@@ -42,6 +42,8 @@ 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.
 
@@ -73,3 +75,40 @@ This is useful for doing things like enabling strict mode only in the theme edit
 
 It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
 It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
+
+### Undefined variables and filters
+
+By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.
+You can improve this situation by passing `strict_variables: true` and/or `strict_filters: true` options to the `render` method.
+When one of these options is set to true, all errors about undefined variables and undefined filters will be stored in `errors` array of a `Liquid::Template` instance.
+Here are some examples:
+
+```ruby
+template = Liquid::Template.parse("{{x}} {{y}} {{z.a}} {{z.b}}")
+template.render({ 'x' => 1, 'z' => { 'a' => 2 } }, { strict_variables: true })
+#=> '1  2 ' # when a variable is undefined, it's rendered as nil
+template.errors
+#=> [#<Liquid::UndefinedVariable: Liquid error: undefined variable y>, #<Liquid::UndefinedVariable: Liquid error: undefined variable b>]
+```
+
+```ruby
+template = Liquid::Template.parse("{{x | filter1 | upcase}}")
+template.render({ 'x' => 'foo' }, { strict_filters: true })
+#=> '' # when at least one filter in the filter chain is undefined, a whole expression is rendered as nil
+template.errors
+#=> [#<Liquid::UndefinedFilter: Liquid error: undefined filter filter1>]
+```
+
+If you want to raise on a first exception instead of pushing all of them in `errors`, you can use `render!` method:
+
+```ruby
+template = Liquid::Template.parse("{{x}} {{y}}")
+template.render!({ 'x' => 1}, { strict_variables: true })
+#=> Liquid::UndefinedVariable: Liquid error: undefined variable y
+```
+
+### Usage tracking
+
+To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
+
+Once you have enabled usage tracking, we recommend reporting any events through Github Issues that your system may be logging. It is highly likely this event has been added to consider deprecating or improving code specific to this event, so please raise any concerns.

Rakefile

@@ -1,42 +1,64 @@
+# frozen_string_literal: true
+
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
 require "liquid/version"
 
-task :default => 'test'
+task(default: [:test, :rubocop])
 
-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
 
-desc 'runs test suite with both strict and lax parsers'
+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')
 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"
@@ -44,7 +66,6 @@ task :release => :build do
 end
 
 namespace :benchmark do
-
   desc "Run the liquid benchmark with lax parsing"
   task :run do
     ruby "./performance/benchmark.rb lax"
@@ -56,9 +77,7 @@ namespace :benchmark do
   end
 end
 
-
 namespace :profile do
-
   desc "Run the liquid profile/performance coverage"
   task :run do
     ruby "./performance/profile.rb"
@@ -68,10 +87,20 @@ namespace :profile do
   task :strict do
     ruby "./performance/profile.rb strict"
   end
-
 end
 
-desc "Run example"
+namespace :memory_profile do
+  desc "Run memory profiler"
+  task :run do
+    ruby "./performance/memory_profile.rb"
+  end
+end
+
+desc("Run example")
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"
 end
+
+task :console do
+  exec 'irb -I lib -r liquid'
+end

example/server/example_servlet.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ProductsFilter
   def price(integer)
-    sprintf("$%.2d USD", integer / 100.0)
+    format("$%.2d USD", integer / 100.0)
   end
 
   def prettyprint(text)
-    text.gsub( /\*(.*)\*/, '<b>\1</b>' )
+    text.gsub(/\*(.*)\*/, '<b>\1</b>')
   end
 
   def count(array)
@@ -17,25 +19,28 @@ module ProductsFilter
 end
 
 class Servlet < LiquidServlet
-
   def index
     { 'date' => Time.now }
   end
 
   def products
-    { 'products' => products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
+    { 'products' => products_list, 'more_products' => more_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 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 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'}]
+     { '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' }]
   end
 
   def description
     "List of Products ~ This is a list of products with price and description."
   end
-
 end

example/server/liquid_servlet.rb

@@ -1,5 +1,6 @@
-class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
+# frozen_string_literal: true
 
+class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   def do_GET(req, res)
     handle(:get, req, res)
   end
@@ -10,19 +11,20 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
 
   private
 
-  def handle(type, req, res)
+  def handle(_type, req, res)
-    @request, @response = req, res
+    @request = req
+    @response = res
 
     @request.path_info =~ /(\w+)\z/
-    @action = $1 || 'index'
+    @action = Regexp.last_match(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( File.dirname(__FILE__) + "/templates/#{filename}.liquid" )
+    File.read("#{__dir__}/templates/#{filename}.liquid")
   end
 end

example/server/server.rb

@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 require 'webrick'
 require 'rexml/document'
 
-DIR = File.expand_path(File.dirname(__FILE__))
+require_relative '../../lib/liquid'
-
+require_relative 'liquid_servlet'
-require DIR + '/../../lib/liquid'
+require_relative 'example_servlet'
-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

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 {{products | count}} products in the {{section}} catalog</h2>
+    <h2>There are currently {{all_products | count}} products in the {{section}} catalog</h2>
 
     {% if cool_products %}
       Cool products :)
@@ -31,7 +31,7 @@
 
     <ul id="products">
 
-      {% for product in products %}
+      {% for product in all_products %}
         <li>
           <h2>{{product.name}}</h2>
           Only {{product.price | price }}

lib/liquid.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Copyright (c) 2005 Tobias Luetke
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -21,9 +23,10 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','.freeze
+  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'.freeze
+  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'.freeze
+  VariableAttributeSeparator  = '.'
+  WhitespaceControl           = '-'
   TagStart                    = /\{\%/
   TagEnd                      = /\%\}/
   VariableSignature           = /\(?[\w\-\.\[\]]\)?/
@@ -34,7 +37,7 @@ module Liquid
   QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
   TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
-  AnyStartingTag              = /\{\{|\{\%/
+  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
   PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
@@ -44,26 +47,41 @@ module Liquid
 end
 
 require "liquid/version"
+require 'liquid/parse_tree_visitor'
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
 require 'liquid/drop'
+require 'liquid/tablerowloop_drop'
+require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
 require 'liquid/strainer'
+require 'liquid/expression'
 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/usage'
+require 'liquid/register'
+require 'liquid/static_registers'
 
 # Load all the tags of the standard library
 #
-Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
+Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+Dir["#{__dir__}/liquid/registers/*.rb"].each { |f| require f }

lib/liquid/block.rb

@@ -1,98 +1,45 @@
+# frozen_string_literal: true
+
 module Liquid
   class Block < Tag
-    FullToken         = /\A#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
+    MAX_DEPTH = 100
-    ContentOfVariable = /\A#{VariableStart}(.*)#{VariableEnd}\z/om
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
 
     def initialize(tag_name, markup, options)
       super
-      @block_delimiter = "end#{tag_name}"
+      @blank = true
-    end 
+      @body = nil
+    end
+
+    def parse(tokens)
+      @body = BlockBody.new
+      while parse_body(@body, tokens)
+      end
+    end
+
+    # For backwards compatibility
+    def render(context)
+      @body&.render(context)
+    end
 
     def blank?
       @blank
     end
 
-    def parse(tokens)
+    def nodelist
-      @blank = true
+      @body.nodelist
-      @nodelist ||= []
-      @nodelist.clear
-
-      # All child tags of the current block.
-      @children = []
-
-      while token = tokens.shift
-        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
-              if @block_delimiter == $1
-                end_tag
-                return
-              end
-
-              # fetch the tag from registered blocks
-              if tag = Template.tags[$1]
-                new_tag = tag.parse($1, $2, tokens, @options)
-                @blank &&= new_tag.blank?
-                @nodelist << new_tag
-                @children << 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)
-            @nodelist << new_var
-            @children << new_var
-            @blank = false
-          else
-            @nodelist << token
-            @blank &&= (token =~ /\A\s*\z/)
-          end
-        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
 
-    # warnings of this block and all sub-tags
+    def unknown_tag(tag, _params, _tokens)
-    def warnings
+      if tag == 'else'
-      all_warnings = []
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else",
-      all_warnings.concat(@warnings) if @warnings
+          block_name: block_name)
-
+      elsif tag.start_with?('end')
-      (@children || []).each do |node|
+        raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter",
-        all_warnings.concat(node.warnings || [])
+          tag: tag,
-      end
+          block_name: block_name,
-
+          block_delimiter: block_delimiter)
-      all_warnings
-    end
-
-    def end_tag
-    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.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
       end
     end
 
@@ -100,58 +47,35 @@ module Liquid
       @tag_name
     end
 
-    def create_variable(token)
+    def block_delimiter
-      token.scan(ContentOfVariable) do |content|
+      @block_delimiter ||= "end#{block_name}"
-        return Variable.new(content.first, @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 assert_missing_delimitation!
+    def parse_body(body, tokens)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_name))
+      if parse_context.depth >= MAX_DEPTH
-    end
+        raise StackLevelError, "Nesting too deep"
+      end
+      parse_context.depth += 1
+      begin
+        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
+          @blank &&= body.blank?
 
-    def render_all(list, context)
+          return false if end_tag_name == block_delimiter
-      output = []
+          unless end_tag_name
-      context.resource_limits[:render_length_current] = 0
+            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
-      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
 
-          token_output = (token.respond_to?(:render) ? token.render(context) : token)
+          # this tag is not registered with the system
-          context.increment_used_resources(:render_length_current, token_output)
+          # pass it to the current block for special handling or error reporting
-          if context.resource_limits_reached?
+          unknown_tag(end_tag_name, end_tag_params, tokens)
-            context.resource_limits[:reached] = true
-            raise MemoryError.new("Memory limits exceeded".freeze)
-          end
-          unless token.is_a?(Block) && token.blank?
-            output << token_output
-          end
-        rescue MemoryError => e
-          raise e
-        rescue ::StandardError => e
-          output << (context.handle_error(e))
         end
+      ensure
+        parse_context.depth -= 1
       end
 
-      output.join
+      true
     end
   end
 end

lib/liquid/block_body.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+module Liquid
+  class BlockBody
+    LiquidTagToken = /\A\s*(\w+)\s*(.*?)\z/o
+    FullToken = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    WhitespaceOrNothing = /\A\s*\z/
+    TAGSTART = "{%"
+    VARSTART = "{{"
+
+    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") + Regexp.last_match(3).count("\n")
+          end
+
+          if tag_name == 'liquid'
+            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)
+      if node.disabled?(context)
+        output << node.disabled_error_message
+        return
+      end
+      disable_tags(context, node.disabled_tags) do
+        node.render_to_output_buffer(context, output)
+      end
+    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 disable_tags(context, tags, &block)
+      return yield if tags.empty?
+      context.registers[:disabled_tags].disable(tags, &block)
+    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"
+    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", token: token, tag_end: TagEnd.inspect)
+    end
+
+    def raise_missing_variable_terminator(token, parse_context)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
+    end
+
+    def registered_tags
+      Template.tags
+    end
+  end
+end

lib/liquid/condition.rb

@@ -1,55 +1,74 @@
+# frozen_string_literal: true
+
 module Liquid
   # Container for liquid nodes which conveniently wraps decision making logic
   #
   # Example:
   #
-  #   c = Condition.new('1', '==', '1')
+  #   c = Condition.new(1, '==', 1)
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
     @@operators = {
-      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
+      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
-      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<'.freeze  => :<,
+      '<' => :<,
-      '>'.freeze  => :>,
+      '>' => :>,
-      '>='.freeze => :>=,
+      '>=' => :>=,
-      '<='.freeze => :<=,
+      '<=' => :<=,
-      'contains'.freeze => lambda { |cond, left, right| left && right ? left.include?(right) : false }
+      'contains' => 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,
     }
 
     def self.operators
       @@operators
     end
 
-    attr_reader :attachment
+    attr_reader :attachment, :child_condition
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left, @operator, @right = left, operator, right
+      @left = left
-      @child_relation  = nil
+      @operator = operator
+      @right = right
+      @child_relation = nil
       @child_condition = nil
     end
 
     def evaluate(context = Context.new)
-      result = interpret_condition(left, right, operator, context)
+      condition = self
+      result = nil
+      loop do
+        result = interpret_condition(condition.left, condition.right, condition.operator, context)
 
-      case @child_relation
+        case condition.child_relation
-      when :or
+        when :or
-        result || @child_condition.evaluate(context)
+          break if result
-      when :and
+        when :and
-        result && @child_condition.evaluate(context)
+          break unless result
-      else
+        else
-        result
+          break
+        end
+        condition = condition.child_condition
       end
+      result
     end
 
     def or(condition)
-      @child_relation, @child_condition = :or, condition
+      @child_relation = :or
+      @child_condition = condition
     end
 
     def and(condition)
-      @child_relation, @child_condition = :and, condition
+      @child_relation = :and
+      @child_condition = condition
     end
 
     def attach(attachment)
@@ -61,23 +80,27 @@ module Liquid
     end
 
     def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
     end
 
+    protected
+
+    attr_reader :child_relation
+
     private
 
     def equal_variables(left, right)
-      if left.is_a?(Symbol)
+      if left.is_a?(Liquid::Expression::MethodLiteral)
-        if right.respond_to?(left)
+        if right.respond_to?(left.method_name)
-          return right.send(left.to_s)
+          return right.send(left.method_name)
         else
           return nil
         end
       end
 
-      if right.is_a?(Symbol)
+      if right.is_a?(Liquid::Expression::MethodLiteral)
-        if left.respond_to?(right)
+        if left.respond_to?(right.method_name)
-          return left.send(right.to_s)
+          return left.send(right.method_name)
         else
           return nil
         end
@@ -90,31 +113,41 @@ 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[left] if op == nil
+      return context.evaluate(left) if op.nil?
 
-      left, right = context[left], context[right]
+      left = context.evaluate(left)
+      right = context.evaluate(right)
 
-      operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
+      operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
-      elsif left.respond_to?(operation) and right.respond_to?(operation)
+      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
-        left.send(operation, right)
+        begin
-      else
+          left.send(operation, right)
-        nil
+        rescue ::ArgumentError => e
+          raise Liquid::ArgumentError, e.message
+        end
+      end
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.left, @node.right,
+          @node.child_condition, @node.attachment
+        ].compact
       end
     end
   end
 
-
   class ElseCondition < Condition
     def else?
       true
     end
 
-    def evaluate(context)
+    def evaluate(_context)
       true
     end
   end
-
 end

lib/liquid/context.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # Context keeps the variable stack and resolves variables, as well as keywords
   #
   #   context['variable'] = 'testing'
@@ -13,38 +14,41 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    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_accessor :rethrow_errors
+    # rubocop:disable Metrics/ParameterLists
+    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {})
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments)
+    end
 
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {})
+      @environments = [environments]
+      @environments.flatten!
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
+      @static_environments = [static_environments].flat_map(&:freeze).freeze
-      @environments    = [environments].flatten
+      @scopes              = [(outer_scope || {})]
-      @scopes          = [(outer_scope || {})]
+      @registers           = registers
-      @registers       = registers
+      @errors              = []
-      @errors          = []
+      @partial             = false
-      @rethrow_errors  = rethrow_errors
+      @strict_variables    = false
-      @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
+      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      @base_scope_depth    = 0
       squash_instance_assigns_with_environments
 
+      self.exception_renderer = Template.default_exception_renderer
+      if rethrow_errors
+        self.exception_renderer = ->(_e) { raise }
+      end
+
       @interrupts = []
       @filters = []
-      @parsed_variables = Hash.new{ |cache, markup| cache[markup] = variable_parse(markup) } 
+      @global_filter = nil
     end
+    # rubocop:enable Metrics/ParameterLists
 
-    def increment_used_resources(key, obj)
+    def warnings
-      @resource_limits[key] += if obj.kind_of?(String) || obj.kind_of?(Array) || obj.kind_of?(Hash)
+      @warnings ||= []
-        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
@@ -57,25 +61,16 @@ module Liquid
     # for that
     def add_filters(filters)
       filters = [filters].flatten.compact
-      filters.each do |f|
+      @filters += filters
-        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
+      @strainer = nil
-        Strainer.add_known_filter(f)
+    end
-      end
 
-      # If strainer is already setup then there's no choice but to use a runtime
+    def apply_global_filter(obj)
-      # extend call. If strainer is not yet created, we can utilize strainers
+      global_filter.nil? ? obj : global_filter.call(obj)
-      # 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 has_interrupt?
+    def interrupt?
       !@interrupts.empty?
     end
 
@@ -89,26 +84,22 @@ module Liquid
       @interrupts.pop
     end
 
-    def handle_error(e)
+    def handle_error(e, line_number = nil)
+      e = internal_error unless e.is_a?(Liquid::Error)
+      e.template_name ||= template_name
+      e.line_number ||= line_number
       errors.push(e)
-      raise if @rethrow_errors
+      exception_renderer.call(e).to_s
-
-      case e
-      when SyntaxError
-        "Liquid syntax error: #{e.message}"
-      else
-        "Liquid error: #{e.message}"
-      end
     end
 
     def invoke(method, *args)
-      strainer.invoke(method, *args)
+      strainer.invoke(method, *args).to_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)
-      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
+      check_overflow
     end
 
     # Merge a hash of variables in the current local scope
@@ -130,13 +121,32 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope={})
+    def stack(new_scope = {})
       push(new_scope)
       yield
     ensure
       pop
     end
 
+    # Creates a new context inheriting resource limits, filters, environment etc.,
+    # but with an isolated scope.
+    def new_isolated_subcontext
+      check_overflow
+
+      Context.build(
+        resource_limits: resource_limits,
+        static_environments: static_environments,
+        registers: StaticRegisters.new(registers)
+      ).tap do |subcontext|
+        subcontext.base_scope_depth = base_scope_depth + 1
+        subcontext.exception_renderer = exception_renderer
+        subcontext.filters = @filters
+        subcontext.strainer = nil
+        subcontext.errors = errors
+        subcontext.warnings = warnings
+      end
+    end
+
     def clear_instance_assigns
       @scopes[0] = {}
     end
@@ -146,159 +156,106 @@ module Liquid
       @scopes[0][key] = value
     end
 
-    def [](key)
+    # Look up variable, either resolve directly after considering the name. We can directly handle
-      resolve(key)
+    # Strings, digits, floats and booleans (true,false).
+    # If no match is made we lookup the variable in the current scope and
+    # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+    # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+    #
+    # Example:
+    #   products == empty #=> products.empty?
+    def [](expression)
+      evaluate(Expression.parse(expression))
     end
 
-    def has_key?(key)
+    def key?(key)
-      resolve(key) != nil
+      self[key] != nil
     end
 
+    def evaluate(object)
+      object.respond_to?(:evaluate) ? object.evaluate(self) : object
+    end
+
+    # Fetches an object starting at the local scope and then moving up the hierachy
+    def find_variable(key, raise_on_not_found: true)
+      # 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) }
+
+      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)
+      end
+
+      variable = variable.to_liquid
+      variable.context = self if variable.respond_to?(:context=)
+
+      variable
+    end
+
+    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
+      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
+        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)
+      else
+        value
+      end
+    end
+
+    protected
+
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
+
     private
-      LITERALS = {
-        nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-        'true'.freeze  => true,
-        'false'.freeze => false,
-        'blank'.freeze => :blank?,
-        'empty'.freeze => :empty?
-      }
 
-      # Look up variable, either resolve directly after considering the name. We can directly handle
+    attr_reader :base_scope_depth
-      # Strings, digits, floats and booleans (true,false).
+
-      # If no match is made we lookup the variable in the current scope and
+    def try_variable_find_in_environments(key, raise_on_not_found:)
-      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
+      @environments.each do |environment|
-      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
+        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
-      # Example:
+          return found_variable
-      #   products == empty #=> products.empty?
+        end
-      def resolve(key)
+      end
-        if LITERALS.key?(key)
+      @static_environments.each do |environment|
-          LITERALS[key]
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
-        else
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
-          case key
+          return found_variable
-          when /\A'(.*)'\z/m # Single quoted strings
+        end
-            $1
+      end
-          when /\A"(.*)"\z/m # Double quoted strings
+      nil
-            $1
+    end
-          when /\A(-?\d+)\z/ # Integer and floats
+
-            $1.to_i
+    def check_overflow
-          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+      raise StackLevelError, "Nesting too deep" if overflow?
-            (resolve($1).to_i..resolve($2).to_i)
+    end
-          when /\A(-?\d[\d\.]+)\z/ # Floats
+
-            $1.to_f
+    def overflow?
-          else
+      base_scope_depth + @scopes.length > Block::MAX_DEPTH
-            variable(key)
+    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
           end
         end
       end
-
+    end # squash_instance_assigns_with_environments
-      # Fetches an object starting at the local scope and then moving up the hierachy
-      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.has_key?(key) }
-        scope = @scopes[index] if index
-
-        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=)
-
-        return variable
-      end
-
-      def variable_parse(markup)
-        parts = markup.scan(VariableParser)
-        needs_resolution = false
-        if parts.first =~ SQUARE_BRACKETED 
-          needs_resolution = true
-          parts[0] = $1
-        end
-        {:first => parts.shift, :needs_resolution => needs_resolution, :rest => parts} 
-      end
-
-      # Resolves namespaced queries gracefully.
-      #
-      # Example
-      #  @context['hash'] = {"name" => 'tobi'}
-      #  assert_equal 'tobi', @context['hash.name']
-      #  assert_equal 'tobi', @context['hash["name"]']
-      def variable(markup)
-        parts = @parsed_variables[markup]
-
-        first_part = parts[:first] 
-        if parts[:needs_resolution]
-          first_part = resolve(parts[:first])
-        end
-
-        if object = find_variable(first_part)
-
-          parts[:rest].each do |part|
-            part = resolve($1) if part_resolved = (part =~ SQUARE_BRACKETED)
-
-            # 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?(:[]) and
-              ((object.respond_to?(:has_key?) and object.has_key?(part)) or
-               (object.respond_to?(:fetch) and part.is_a?(Integer)))
-
-              # if its a proc we will replace the entry with the proc
-              res = lookup_and_evaluate(object, part)
-              object = res.to_liquid
-
-              # Some special cases. If the part wasn't in square brackets and
-              # no key with the same name was found we interpret following calls
-              # as commands and call them on the current object
-            elsif !part_resolved and object.respond_to?(part) and ['size'.freeze, 'first'.freeze, 'last'.freeze].include?(part)
-
-              object = object.send(part.intern).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
-            else
-              return nil
-            end
-
-            # If we are dealing with a drop here we have to
-            object.context = self if object.respond_to?(:context=)
-          end
-        end
-
-        object
-      end # variable
-
-      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 # lookup_and_evaluate
-
-      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 # squash_instance_assigns_with_environments
   end # Context
-
 end # Liquid

lib/liquid/document.rb

@@ -1,17 +1,29 @@
+# frozen_string_literal: true
+
 module Liquid
-  class Document < Block
+  class Document < BlockBody
-    def self.parse(tokens, options={})
+    def self.parse(tokens, parse_context)
-      # we don't need markup to open this block
+      doc = new
-      super(nil, nil, tokens, options)
+      doc.parse(tokens, parse_context)
+      doc
     end
 
-    # There isn't a real delimiter
+    def parse(tokens, parse_context)
-    def block_delimiter
+      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
     end
 
-    # Document blocks don't need to be terminated since they are not actually opened
+    def unknown_tag(tag, parse_context)
-    def assert_missing_delimitation!
+      case tag
+      when 'else', 'end'
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag", tag: tag)
+      else
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
+      end
     end
   end
 end

lib/liquid/drop.rb

@@ -1,7 +1,8 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module Liquid
-
   # A drop in liquid is a class which allows you to export DOM like things to liquid.
   # Methods of drops are callable.
   # The main use for liquid drops is to implement lazy loaded objects.
@@ -19,28 +20,27 @@ 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 before_method(name) method which is a
+  # Your drop can either implement the methods sans any parameters
-  # catch all.
+  # or implement the liquid_method_missing(name) method which is a catch all.
   class Drop
     attr_writer :context
 
-    EMPTY_STRING = ''.freeze
-
     # Catch all for the method
-    def before_method(method)
+    def liquid_method_missing(method)
-      nil
+      return nil unless @context&.strict_variables
+      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 
     # called by liquid to invoke a drop
     def invoke_drop(method_or_key)
-      if method_or_key && method_or_key != EMPTY_STRING && self.class.invokable?(method_or_key)
+      if self.class.invokable?(method_or_key)
         send(method_or_key)
       else
-        before_method(method_or_key)
+        liquid_method_missing(method_or_key)
       end
     end
 
-    def has_key?(name)
+    def key?(_name)
       true
     end
 
@@ -56,22 +56,25 @@ module Liquid
       self.class.name
     end
 
-    alias :[] :invoke_drop
+    alias_method :[], :invoke_drop
-
-    private
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      unless @invokable_methods
+      invokable_methods.include?(method_name.to_s)
+    end
+
+    def self.invokable_methods
+      @invokable_methods ||= begin
         blacklist = Liquid::Drop.public_instance_methods + [:each]
+
         if include?(Enumerable)
           blacklist += Enumerable.public_instance_methods
-          blacklist -= [:sort, :count, :first, :min, :max, :include?]
+          blacklist -= [:sort, :count, :first, :min, :max]
         end
+
         whitelist = [:to_liquid] + (public_instance_methods - blacklist)
-        @invokable_methods = Set.new(whitelist.map(&:to_s))
+        Set.new(whitelist.map(&:to_s))
       end
-      @invokable_methods.include?(method_name.to_s)
     end
   end
 end

lib/liquid/errors.rb

@@ -1,12 +1,58 @@
-module Liquid
+# frozen_string_literal: true
-  class Error < ::StandardError; end
 
-  class ArgumentError < Error; end
+module Liquid
-  class ContextError < Error; end
+  class Error < ::StandardError
-  class FilterNotFound < Error; end
+    attr_accessor :line_number
-  class FileSystemError < Error; end
+    attr_accessor :template_name
-  class StandardError < Error; end
+    attr_accessor :markup_context
-  class SyntaxError < Error; end
+
-  class StackLevelError < Error; end
+    def to_s(with_prefix = true)
-  class MemoryError < Error; end
+      str = +""
+      str << message_prefix if with_prefix
+      str << super()
+
+      if markup_context
+        str << " "
+        str << markup_context
+      end
+
+      str
+    end
+
+    private
+
+    def message_prefix
+      str = +""
+      str << if is_a?(SyntaxError)
+        "Liquid syntax error"
+      else
+        "Liquid error"
+      end
+
+      if line_number
+        str << " ("
+        str << template_name << " " if template_name
+        str << "line " << line_number.to_s << ")"
+      end
+
+      str << ": "
+      str
+    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)
 end

lib/liquid/expression.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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' => nil, 'null' => nil, '' => nil,
+      'true' => true,
+      'false' => false,
+      'blank' => MethodLiteral.new(:blank?, '').freeze,
+      'empty' => MethodLiteral.new(:empty?, '').freeze
+    }.freeze
+
+    SINGLE_QUOTED_STRING = /\A'(.*)'\z/m
+    DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m
+    INTEGERS_REGEX       = /\A(-?\d+)\z/
+    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/
+    RANGES_REGEX         = /\A\((\S+)\.\.(\S+)\)\z/
+
+    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
+        else
+          VariableLookup.parse(markup)
+        end
+      end
+    end
+  end
+end

lib/liquid/extensions.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'time'
 require 'date'
 
@@ -7,44 +9,56 @@ class String # :nodoc:
   end
 end
 
-class Array  # :nodoc:
+class Symbol # :nodoc:
+  def to_liquid
+    to_s
+  end
+end
+
+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 Time  # :nodoc:
+class Range # :nodoc:
   def to_liquid
     self
   end
 end
 
-class DateTime < Date  # :nodoc:
+class Time # :nodoc:
   def to_liquid
     self
   end
 end
 
-class Date  # :nodoc:
+class DateTime < Date # :nodoc:
+  def to_liquid
+    self
+  end
+end
+
+class Date # :nodoc:
   def to_liquid
     self
   end
 end
 
 class TrueClass
-  def to_liquid  # :nodoc:
+  def to_liquid # :nodoc:
     self
   end
 end

lib/liquid/file_system.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
   # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag.
   #
@@ -8,13 +10,13 @@ module Liquid
   #
   # Example:
   #
-  # Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+  #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
-  # liquid = Liquid::Template.parse(template)
+  #   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, context)
+    def read_template_file(_template_path)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -26,10 +28,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("mypartial")       # => "/some/path/_mypartial.liquid"
-  # file_system.full_path("dir/mypartial")   # => "/some/path/dir/_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,35 +39,35 @@ module Liquid
   #
   # Example:
   #
-  # file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+  #   file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
   #
-  # file_system.full_path("index") # => "/some/path/index.html"
+  #   file_system.full_path("index") # => "/some/path/index.html"
   #
   class LocalFileSystem
     attr_accessor :root
 
-    def initialize(root, pattern = "_%s.liquid".freeze)
+    def initialize(root, pattern = "_%s.liquid")
       @root = root
       @pattern = pattern
     end
 
-    def read_template_file(template_path, context)
+    def read_template_file(template_path)
       full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
 
       File.read(full_path)
     end
 
     def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless %r{\A[^./][a-zA-Z0-9_/]+\z}.match?(template_path)
 
-      full_path = if template_path.include?('/'.freeze)
+      full_path = if template_path.include?('/')
         File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
       else
         File.join(root, @pattern % template_path)
       end
 
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /\A#{File.expand_path(root)}/
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path).start_with?(File.expand_path(root))
 
       full_path
     end

lib/liquid/forloop_drop.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Liquid
+  class ForloopDrop < Drop
+    def initialize(name, length, parentloop)
+      @name = name
+      @length = length
+      @parentloop = parentloop
+      @index = 0
+    end
+
+    attr_reader :name, :length, :parentloop
+
+    def index
+      @index + 1
+    end
+
+    def index0
+      @index
+    end
+
+    def rindex
+      @length - @index
+    end
+
+    def rindex0
+      @length - @index - 1
+    end
+
+    def first
+      @index == 0
+    end
+
+    def last
+      @index == @length - 1
+    end
+
+    protected
+
+    def increment!
+      @index += 1
+    end
+  end
+end

lib/liquid/i18n.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module Liquid
   class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
+    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
 
-    class TranslationError < StandardError
+    TranslationError = Class.new(StandardError)
-    end
 
     attr_reader :path
 
@@ -23,16 +24,17 @@ module Liquid
     end
 
     private
+
     def interpolate(name, vars)
-      name.gsub(/%\{(\w+)\}/) {
+      name.gsub(/%\{(\w+)\}/) do
         # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        "#{vars[$1.to_sym]}"
+        (vars[Regexp.last_match(1).to_sym]).to_s
-      }
+      end
     end
 
     def deep_fetch_translation(name)
-      name.split('.'.freeze).reduce(locale) do |level, cur|
+      name.split('.').reduce(locale) do |level, cur|
-        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
+        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
       end
     end
   end

lib/liquid/interrupts.rb

@@ -1,11 +1,12 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # An interrupt is any command that breaks processing of a block (ex: a for loop).
   class Interrupt
     attr_reader :message
 
-    def initialize(message=nil)
+    def initialize(message = nil)
-      @message = message || "interrupt".freeze
+      @message = message || "interrupt"
     end
   end
 

lib/liquid/lexer.rb

@@ -1,43 +1,54 @@
+# frozen_string_literal: true
+
 require "strscan"
 module Liquid
   class Lexer
     SPECIALS = {
-      '|'.freeze => :pipe,
+      '|' => :pipe,
-      '.'.freeze => :dot,
+      '.' => :dot,
-      ':'.freeze => :colon,
+      ':' => :colon,
-      ','.freeze => :comma,
+      ',' => :comma,
-      '['.freeze => :open_square,
+      '[' => :open_square,
-      ']'.freeze => :close_square,
+      ']' => :close_square,
-      '('.freeze => :open_round,
+      '(' => :open_round,
-      ')'.freeze => :close_round
+      ')' => :close_round,
-    }
+      '?' => :question,
-    IDENTIFIER = /[\w\-?!]+/
+      '-' => :dash,
+    }.freeze
+    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
     NUMBER_LITERAL = /-?\d+(\.\d+)?/
     DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    WHITESPACE_OR_NOTHING = /\s*/
 
     def initialize(input)
-      @ss = StringScanner.new(input.rstrip)
+      @ss = StringScanner.new(input)
     end
 
     def tokenize
       @output = []
 
-      while !@ss.eos?
+      until @ss.eos?
-        @ss.skip(/\s*/)
+        @ss.skip(WHITESPACE_OR_NOTHING)
-        tok = case
+        break if @ss.eos?
-        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        tok = if (t = @ss.scan(COMPARISON_OPERATOR))
-        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+          [:comparison, t]
-        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
-        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+          [:string, t]
-        when t = @ss.scan(IDENTIFIER) then [:id, t]
+        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL))
-        when t = @ss.scan(DOTDOT) then [:dotdot, t]
+          [:string, t]
+        elsif (t = @ss.scan(NUMBER_LITERAL))
+          [:number, t]
+        elsif (t = @ss.scan(IDENTIFIER))
+          [:id, t]
+        elsif (t = @ss.scan(DOTDOT))
+          [:dotdot, t]
         else
           c = @ss.getch
-          if s = SPECIALS[c]
+          if (s = SPECIALS[c])
-            [s,c]
+            [s, c]
           else
             raise SyntaxError, "Unexpected character #{c}"
           end

lib/liquid/locales/en.yml

@@ -1,6 +1,7 @@
 ---
   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]"
@@ -13,10 +14,16 @@
       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: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      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_else: "%{block_name} tag does not expect 'else' tag"
+      unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
       tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
       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"
+    disabled:
+      tag: "usage is not allowed in this context"

lib/liquid/module_ex.rb

@@ -1,62 +0,0 @@
-# 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

lib/liquid/parse_context.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Liquid
+  class ParseContext
+    attr_accessor :locale, :line_number, :trim_whitespace, :depth
+    attr_reader :partial, :warnings, :error_mode
+
+    def initialize(options = {})
+      @template_options = options ? options.dup : {}
+      @locale = @template_options[:locale] ||= I18n.new
+      @warnings = []
+      self.depth = 0
+      self.partial = false
+    end
+
+    def [](option_key)
+      @options[option_key]
+    end
+
+    def partial=(value)
+      @partial = value
+      @options = value ? partial_options : @template_options
+      @error_mode = @options[:error_mode] || Template.error_mode
+    end
+
+    def partial_options
+      @partial_options ||= begin
+        dont_pass = @template_options[:include_options_blacklist]
+        if dont_pass == true
+          { locale: locale }
+        elsif dont_pass.is_a?(Array)
+          @template_options.reject { |k, _v| dont_pass.include?(k) }
+        else
+          @template_options
+        end
+      end
+    end
+  end
+end

lib/liquid/parse_tree_visitor.rb

@@ -0,0 +1,42 @@
+# 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

lib/liquid/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
   class Parser
     def initialize(input)
@@ -44,11 +46,14 @@ 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 [:string, :number].include? token[0]
+      elsif SINGLE_TOKEN_EXPRESSION_TYPES.include?(token[0])
         consume
       elsif token.first == :open_round
         consume
@@ -63,10 +68,10 @@ module Liquid
     end
 
     def argument
-      str = ""
+      str = +""
       # might be a keyword argument (identifier: expression)
       if look(:id) && look(:colon, 1)
-        str << consume << consume << ' '.freeze
+        str << consume << consume << ' '
       end
 
       str << expression
@@ -75,7 +80,7 @@ module Liquid
 
     def variable_signature
       str = consume(:id)
-      if look(:open_square)
+      while look(:open_square)
         str << consume
         str << expression
         str << consume(:close_square)

lib/liquid/parser_switching.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Liquid
+  module ParserSwitching
+    def parse_with_selected_parser(markup)
+      case parse_context.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
+          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
+
+    def markup_context(markup)
+      "in \"#{markup.strip}\""
+    end
+  end
+end

lib/liquid/partial_cache.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Liquid
+  class PartialCache
+    def self.load(template_name, context:, parse_context:)
+      cached_partials = (context.registers[:cached_partials] ||= {})
+      cached = cached_partials[template_name]
+      return cached if cached
+
+      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
+      source = file_system.read_template_file(template_name)
+      parse_context.partial = true
+
+      partial = Liquid::Template.parse(source, parse_context)
+      cached_partials[template_name] = partial
+    ensure
+      parse_context.partial = false
+    end
+  end
+end

lib/liquid/profiler.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+require 'liquid/profiler/hooks'
+
+module Liquid
+  # Profiler enables support for profiling template rendering to help track down performance issues.
+  #
+  # To enable profiling, first require 'liquid/profiler'.
+  # 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
+  # class via the <tt>Liquid::Template#profiler</tt> method.
+  #
+  #   template = Liquid::Template.parse(template_content, profile: true)
+  #   output  = template.render
+  #   profile = template.profiler
+  #
+  # This object contains all profiling information, containing information on what tags were rendered,
+  # where in the templates these tags live, and how long each tag took to render.
+  #
+  # This is a tree structure that is Enumerable all the way down, and keeps track of tags and rendering times
+  # inside of <tt>{% include %}</tt> tags.
+  #
+  #   profile.each do |node|
+  #     # Access to the node itself
+  #     node.code
+  #
+  #     # Which template and line number of this node.
+  #     # If top level, this will be "<root>".
+  #     node.partial
+  #     node.line_number
+  #
+  #     # Render time in seconds of this node
+  #     node.render_time
+  #
+  #     # If the template used {% include %}, this node will also have children.
+  #     node.children.each do |child2|
+  #       # ...
+  #     end
+  #   end
+  #
+  # Profiler also exposes the total time of the template's render in <tt>Liquid::Profiler#total_render_time</tt>.
+  #
+  # All render times are in seconds. There is a small performance hit when profiling is enabled.
+  #
+  class Profiler
+    include Enumerable
+
+    class Timing
+      attr_reader :code, :partial, :line_number, :children, :total_time, :self_time
+
+      def initialize(node, partial)
+        @code        = node.respond_to?(:raw) ? node.raw : node
+        @partial     = partial
+        @line_number = node.respond_to?(:line_number) ? node.line_number : nil
+        @children    = []
+      end
+
+      def self.start(node, partial)
+        new(node, partial).tap(&:start)
+      end
+
+      def start
+        @start_time = Time.now
+      end
+
+      def finish
+        @end_time = Time.now
+        @total_time = @end_time - @start_time
+
+        if @children.empty?
+          @self_time = @total_time
+        else
+          total_children_time = 0
+          @children.each do |child|
+            total_children_time += child.total_time
+          end
+          @self_time = @total_time - total_children_time
+        end
+      end
+
+      def render_time
+        @end_time - @start_time
+      end
+    end
+
+    def self.profile_node_render(node)
+      if Profiler.current_profile && node.respond_to?(:render)
+        Profiler.current_profile.start_node(node)
+        output = yield
+        Profiler.current_profile.end_node(node)
+        output
+      else
+        yield
+      end
+    end
+
+    def self.profile_children(template_name)
+      if Profiler.current_profile
+        Profiler.current_profile.push_partial(template_name)
+        output = yield
+        Profiler.current_profile.pop_partial
+        output
+      else
+        yield
+      end
+    end
+
+    def self.current_profile
+      Thread.current[:liquid_profiler]
+    end
+
+    def initialize(partial_name = "<root>")
+      @partial_stack = [partial_name]
+
+      @root_timing = Timing.new("", current_partial)
+      @timing_stack = [@root_timing]
+
+      @render_start_at = Time.now
+      @render_end_at = @render_start_at
+    end
+
+    def start
+      Thread.current[:liquid_profiler] = self
+      @render_start_at = Time.now
+    end
+
+    def stop
+      Thread.current[:liquid_profiler] = nil
+      @render_end_at = Time.now
+    end
+
+    def total_render_time
+      @render_end_at - @render_start_at
+    end
+
+    def each(&block)
+      @root_timing.children.each(&block)
+    end
+
+    def [](idx)
+      @root_timing.children[idx]
+    end
+
+    def length
+      @root_timing.children.length
+    end
+
+    def start_node(node)
+      @timing_stack.push(Timing.start(node, current_partial))
+    end
+
+    def end_node(_node)
+      timing = @timing_stack.pop
+      timing.finish
+
+      @timing_stack.last.children << timing
+    end
+
+    def current_partial
+      @partial_stack.last
+    end
+
+    def push_partial(partial_name)
+      @partial_stack.push(partial_name)
+    end
+
+    def pop_partial
+      @partial_stack.pop
+    end
+  end
+end

lib/liquid/profiler/hooks.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+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)
+      end
+    end
+
+    alias_method :render_node_without_profiling, :render_node
+    alias_method :render_node, :render_node_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)
+      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
+  end
+end

lib/liquid/range_lookup.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Liquid
+  class RangeLookup
+    def self.parse(start_markup, end_markup)
+      start_obj = Expression.parse(start_markup)
+      end_obj = Expression.parse(end_markup)
+      if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
+        new(start_obj, end_obj)
+      else
+        start_obj.to_i..end_obj.to_i
+      end
+    end
+
+    def initialize(start_obj, end_obj)
+      @start_obj = start_obj
+      @end_obj = end_obj
+    end
+
+    def evaluate(context)
+      start_int = to_integer(context.evaluate(@start_obj))
+      end_int = to_integer(context.evaluate(@end_obj))
+      start_int..end_int
+    end
+
+    private
+
+    def to_integer(input)
+      case input
+      when Integer
+        input
+      when NilClass, String
+        input.to_i
+      else
+        Utils.to_integer(input)
+      end
+    end
+  end
+end

lib/liquid/register.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Register
+  end
+end

lib/liquid/registers/disabled_tags.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module Liquid
+  class DisabledTags < Register
+    def initialize
+      @disabled_tags = {}
+    end
+
+    def disabled?(tag)
+      @disabled_tags.key?(tag) && @disabled_tags[tag] > 0
+    end
+
+    def disable(tags)
+      tags.each(&method(:increment))
+      yield
+    ensure
+      tags.each(&method(:decrement))
+    end
+
+    private
+
+    def increment(tag)
+      @disabled_tags[tag] ||= 0
+      @disabled_tags[tag] += 1
+    end
+
+    def decrement(tag)
+      @disabled_tags[tag] -= 1
+    end
+  end
+
+  Template.add_register(:disabled_tags, DisabledTags.new)
+end

lib/liquid/resource_limits.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Liquid
+  class ResourceLimits
+    attr_accessor :render_length, :render_score, :assign_score,
+      :render_length_limit, :render_score_limit, :assign_score_limit
+
+    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

lib/liquid/standardfilters.rb

@@ -1,17 +1,24 @@
+# frozen_string_literal: true
+
 require 'cgi'
 require 'bigdecimal'
 
 module Liquid
-
   module StandardFilters
     HTML_ESCAPE = {
-      '&'.freeze => '&'.freeze,
+      '&' => '&',
-      '>'.freeze => '>'.freeze,
+      '>' => '>',
-      '<'.freeze => '&lt;'.freeze,
+      '<' => '&lt;',
-      '"'.freeze => '&quot;'.freeze,
+      '"' => '&quot;',
-      "'".freeze => '&#39;'.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)
@@ -34,29 +41,56 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input) rescue input
+      CGI.escapeHTML(input.to_s).untaint unless input.nil?
     end
+    alias_method :h, :escape
 
     def escape_once(input)
       input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
     end
 
-    alias_method :h, :escape
+    def url_encode(input)
-
+      CGI.escape(input.to_s) unless input.nil?
-    # Truncate a string down to x characters
-    def truncate(input, length = 50, truncate_string = "...".freeze)
-      if input.nil? then return end
-      l = length.to_i - truncate_string.length
-      l = 0 if l < 0
-      input.length > length.to_i ? input[0...l] + truncate_string : input
     end
 
-    def truncatewords(input, words = 15, truncate_string = "...".freeze)
+    def url_decode(input)
-      if input.nil? then return end
+      return if input.nil?
-      wordlist = input.to_s.split
+
-      l = words.to_i - 1
+      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
+
+      if input.is_a?(Array)
+        input.slice(offset, length) || []
+      else
+        input.to_s.slice(offset, length) || ''
+      end
+    end
+
+    # Truncate a string down to x characters
+    def truncate(input, length = 50, truncate_string = "...")
+      return if input.nil?
+      input_str = input.to_s
+      length = Utils.to_integer(length)
+      truncate_string_str = truncate_string.to_s
+      l = length - truncate_string_str.length
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
+      input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
+    end
+
+    def truncatewords(input, words = 15, truncate_string = "...")
+      return if input.nil?
+      wordlist = input.to_s.split
+      words = Utils.to_integer(words)
+      l = words - 1
+      l = 0 if l < 0
+      wordlist.length > l ? wordlist[0..l].join(" ").concat(truncate_string.to_s) : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -65,7 +99,7 @@ module Liquid
     #   <div class="summary">{{ post | split '//' | first }}</div>
     #
     def split(input, pattern)
-      input.split(pattern)
+      input.to_s.split(pattern.to_s)
     end
 
     def strip(input)
@@ -81,70 +115,160 @@ module Liquid
     end
 
     def strip_html(input)
-      empty = ''.freeze
+      empty = ''
-      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
+      result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
+      result.gsub!(STRIP_HTML_TAGS, empty)
+      result
     end
 
     # Remove all newlines from the string
     def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, ''.freeze)
+      input.to_s.gsub(/\r?\n/, '')
     end
 
     # Join elements of the array with certain character between them
-    def join(input, glue = ' '.freeze)
+    def join(input, glue = ' ')
-      [input].flatten.join(glue)
+      InputIterator.new(input, context).join(glue)
     end
 
     # Sort elements of the array
     # provide optional property with which to sort an array of hashes or drops
     def sort(input, property = nil)
-      ary = flatten_if_necessary(input)
+      ary = InputIterator.new(input, context)
+
+      return [] if ary.empty?
+
       if property.nil?
-        ary.sort
+        ary.sort do |a, b|
-      elsif ary.first.respond_to?('[]'.freeze) and !ary.first[property].nil?
+          nil_safe_compare(a, b)
-        ary.sort {|a,b| a[property] <=> b[property] }
+        end
-      elsif ary.first.respond_to?(property)
+      elsif ary.all? { |el| el.respond_to?(:[]) }
-        ary.sort {|a,b| a.send(property) <=> b.send(property) }
+        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, context)
+
+      return [] if ary.empty?
+
+      if property.nil?
+        ary.sort do |a, b|
+          nil_safe_casecmp(a, b)
+        end
+      elsif ary.all? { |el| el.respond_to?(:[]) }
+        begin
+          ary.sort { |a, b| nil_safe_casecmp(a[property], b[property]) }
+        rescue TypeError
+          raise_property_error(property)
+        end
+      end
+    end
+
+    # Filter the elements of an array to those with a certain property value.
+    # By default the target is any truthy value.
+    def where(input, property, target_value = nil)
+      ary = InputIterator.new(input, context)
+
+      if ary.empty?
+        []
+      elsif ary.first.respond_to?(:[]) && target_value.nil?
+        begin
+          ary.select { |item| item[property] }
+        rescue TypeError
+          raise_property_error(property)
+        end
+      elsif ary.first.respond_to?(:[])
+        begin
+          ary.select { |item| item[property] == target_value }
+        rescue TypeError
+          raise_property_error(property)
+        end
+      end
+    end
+
+    # Remove duplicate elements from an array
+    # provide optional property with which to determine uniqueness
+    def uniq(input, property = nil)
+      ary = InputIterator.new(input, context)
+
+      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
       end
     end
 
     # Reverse the elements of an array
     def reverse(input)
-      ary = [input].flatten
+      ary = InputIterator.new(input, context)
       ary.reverse
     end
 
     # map/collect on a given property
     def map(input, property)
-      flatten_if_necessary(input).map do |e|
+      InputIterator.new(input, context).map do |e|
         e = e.call if e.is_a?(Proc)
 
-        if property == "to_liquid".freeze
+        if property == "to_liquid"
           e
         elsif e.respond_to?(:[])
-          e[property]
+          r = e[property]
+          r.is_a?(Proc) ? r.call : r
+        end
+      end
+    rescue TypeError
+      raise_property_error(property)
+    end
+
+    # Remove nils within an array
+    # provide optional property with which to check for nil
+    def compact(input, property = nil)
+      ary = InputIterator.new(input, context)
+
+      if property.nil?
+        ary.compact
+      elsif ary.empty? # The next two cases assume a non-empty array.
+        []
+      elsif ary.first.respond_to?(:[])
+        begin
+          ary.reject { |a| a[property].nil? }
+        rescue TypeError
+          raise_property_error(property)
         end
       end
     end
 
     # Replace occurrences of a string with another
-    def replace(input, string, replacement = ''.freeze)
+    def replace(input, string, replacement = '')
-      input.to_s.gsub(string, replacement.to_s)
+      input.to_s.gsub(string.to_s, replacement.to_s)
     end
 
     # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = ''.freeze)
+    def replace_first(input, string, replacement = '')
-      input.to_s.sub(string, replacement.to_s)
+      input.to_s.sub(string.to_s, replacement.to_s)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, ''.freeze)
+      input.to_s.gsub(string.to_s, '')
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, ''.freeze)
+      input.to_s.sub(string.to_s, '')
     end
 
     # add one string to another
@@ -152,6 +276,13 @@ 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, context).concat(array)
+    end
+
     # prepend a string to another
     def prepend(input, string)
       string.to_s + input.to_s
@@ -159,7 +290,7 @@ module Liquid
 
     # Add <br /> tags in front of all newlines in input string
     def newline_to_br(input)
-      input.to_s.gsub(/\n/, "<br />\n".freeze)
+      input.to_s.gsub(/\n/, "<br />\n")
     end
 
     # Reformat a date using Ruby's core Time#strftime( string ) -> string
@@ -196,7 +327,7 @@ module Liquid
     def date(input, format)
       return input if format.to_s.empty?
 
-      return input unless date = to_date(input)
+      return input unless (date = Utils.to_date(input))
 
       date.strftime(format.to_s)
     end
@@ -219,6 +350,12 @@ 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, :+)
@@ -237,79 +374,146 @@ 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 = to_number(input).round(to_number(n))
+      result = Utils.to_number(input).round(Utils.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)
-      to_number(input).ceil.to_i
+      Utils.to_number(input).ceil.to_i
+    rescue ::FloatDomainError => e
+      raise Liquid::FloatDomainError, e.message
     end
 
     def floor(input)
-      to_number(input).floor.to_i
+      Utils.to_number(input).floor.to_i
+    rescue ::FloatDomainError => e
+      raise Liquid::FloatDomainError, e.message
     end
 
-    def default(input, default_value = "".freeze)
+    def at_least(input, n)
-      is_blank = input.respond_to?(:empty?) ? input.empty? : !input
+      min_value = Utils.to_number(n)
-      is_blank ? default_value : input
+
+      result = Utils.to_number(input)
+      result = min_value if min_value > result
+      result.is_a?(BigDecimal) ? result.to_f : result
+    end
+
+    def at_most(input, n)
+      max_value = Utils.to_number(n)
+
+      result = Utils.to_number(input)
+      result = max_value if max_value < result
+      result.is_a?(BigDecimal) ? result.to_f : result
+    end
+
+    # Set a default value when the input is nil, false or empty
+    #
+    # Example:
+    #    {{ product.title | default: "No Title" }}
+    #
+    # Use `allow_false` when an input should only be tested against nil or empty and not false.
+    #
+    # Example:
+    #    {{ product.title | default: "No Title", allow_false: true }}
+    #
+    def default(input, default_value = '', options = {})
+      options = {} unless options.is_a?(Hash)
+      false_check = options['allow_false'] ? input.nil? : !input
+      false_check || (input.respond_to?(:empty?) && input.empty?) ? default_value : input
     end
 
     private
 
-    def flatten_if_necessary(input)
+    attr_reader :context
-      ary = if input.is_a?(Array)
-        input.flatten
-      elsif input.is_a?(Enumerable) && !input.is_a?(Hash)
-        input
-      else
-        [input].flatten
-      end
-      ary.map{ |e| e.respond_to?(:to_liquid) ? e.to_liquid : e }
-    end
 
-    def to_number(obj)
+    def raise_property_error(property)
-      case obj
+      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
-      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 = to_number(input).send(operation, to_number(operand))
+      result = Utils.to_number(input).send(operation, Utils.to_number(operand))
       result.is_a?(BigDecimal) ? result.to_f : result
     end
+
+    def nil_safe_compare(a, b)
+      if !a.nil? && !b.nil?
+        a <=> b
+      else
+        a.nil? ? 1 : -1
+      end
+    end
+
+    def nil_safe_casecmp(a, b)
+      if !a.nil? && !b.nil?
+        a.to_s.casecmp(b.to_s)
+      else
+        a.nil? ? 1 : -1
+      end
+    end
+
+    class InputIterator
+      include Enumerable
+
+      def initialize(input, context)
+        @context = context
+        @input = if input.is_a?(Array)
+          input.flatten
+        elsif input.is_a?(Hash)
+          [input]
+        elsif input.is_a?(Enumerable)
+          input
+        else
+          Array(input)
+        end
+      end
+
+      def join(glue)
+        to_a.join(glue.to_s)
+      end
+
+      def concat(args)
+        to_a.concat(args)
+      end
+
+      def reverse
+        reverse_each.to_a
+      end
+
+      def uniq(&block)
+        to_a.uniq(&block)
+      end
+
+      def compact
+        to_a.compact
+      end
+
+      def empty?
+        @input.each { return false }
+        true
+      end
+
+      def each
+        @input.each do |e|
+          e.context = @context if e.respond_to?(:context=)
+          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
+        end
+      end
+    end
   end
 
   Template.register_filter(StandardFilters)

lib/liquid/static_registers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Liquid
+  class StaticRegisters
+    attr_reader :static, :registers
+
+    def initialize(registers = {})
+      @static = registers.is_a?(StaticRegisters) ? registers.static : registers
+      @registers = {}
+    end
+
+    def []=(key, value)
+      @registers[key] = value
+    end
+
+    def [](key)
+      if @registers.key?(key)
+        @registers[key]
+      else
+        @static[key]
+      end
+    end
+
+    def delete(key)
+      @registers.delete(key)
+    end
+
+    def fetch(key, default = nil)
+      key?(key) ? self[key] : default
+    end
+
+    def key?(key)
+      @registers.key?(key) || @static.key?(key)
+    end
+  end
+end

lib/liquid/strainer.rb

@@ -1,19 +1,21 @@
+# frozen_string_literal: true
+
 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:
-    @@filters = []
+    @@global_strainer = Class.new(Strainer) do
-    @@known_filters = Set.new
+      @filter_methods = Set.new
-    @@known_methods = Set.new
+    end
     @@strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(Strainer) do
+      hash[filters] = Class.new(@@global_strainer) do
-        filters.each { |f| include f }
+        @filter_methods = @@global_strainer.filter_methods.dup
+        filters.each { |f| add_filter(f) }
       end
     end
 
@@ -21,43 +23,46 @@ module Liquid
       @context = context
     end
 
-    def self.global_filter(filter)
+    class << self
-      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
+      attr_reader :filter_methods
-      add_known_filter(filter)
-      @@filters << filter unless @@filters.include?(filter)
     end
 
-    def self.add_known_filter(filter)
+    def self.add_filter(filter)
-      unless @@known_filters.include?(filter)
+      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
+      unless include?(filter)
-        new_methods = filter.instance_methods.map(&:to_s)
+        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
-        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
+        if invokable_non_public_methods.any?
-        @@known_methods.merge(new_methods)
+          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
-        @@known_filters.add(filter)
+        else
+          send(:include, filter)
+          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+        end
       end
     end
 
-    def self.strainer_class_cache
+    def self.global_filter(filter)
-      @@strainer_class_cache
+      @@strainer_class_cache.clear
+      @@global_strainer.add_filter(filter)
+    end
+
+    def self.invokable?(method)
+      @filter_methods.include?(method.to_s)
     end
 
     def self.create(context, filters = [])
-      filters = @@filters + filters
+      @@strainer_class_cache[filters].new(context)
-      strainer_class_cache[filters].new(context)
     end
 
     def invoke(method, *args)
-      if invokable?(method)
+      if self.class.invokable?(method)
         send(method, *args)
+      elsif @context&.strict_filters
+        raise Liquid::UndefinedFilter, "undefined filter #{method}"
       else
         args.first
       end
     rescue ::ArgumentError => e
-      raise Liquid::ArgumentError.new(e.message)
+      raise Liquid::ArgumentError, e.message, e.backtrace
-    end
-
-    def invokable?(method)
-      @@known_methods.include?(method.to_s) && respond_to?(method)
     end
   end
 end

lib/liquid/tablerowloop_drop.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Liquid
+  class TablerowloopDrop < Drop
+    def initialize(length, cols)
+      @length = length
+      @row = 1
+      @col = 1
+      @cols = cols
+      @index = 0
+    end
+
+    attr_reader :length, :col, :row
+
+    def index
+      @index + 1
+    end
+
+    def index0
+      @index
+    end
+
+    def col0
+      @col - 1
+    end
+
+    def rindex
+      @length - @index
+    end
+
+    def rindex0
+      @length - @index - 1
+    end
+
+    def first
+      @index == 0
+    end
+
+    def last
+      @index == @length - 1
+    end
+
+    def col_first
+      @col == 1
+    end
+
+    def col_last
+      @col == @cols
+    end
+
+    protected
+
+    def increment!
+      @index += 1
+
+      if @col == @cols
+        @col = 1
+        @row += 1
+      else
+        @col += 1
+      end
+    end
+  end
+end

lib/liquid/tag.rb

@@ -1,61 +1,71 @@
+# frozen_string_literal: true
+
 module Liquid
   class Tag
-    attr_accessor :options
+    attr_reader :nodelist, :tag_name, :line_number, :parse_context, :markup
-    attr_reader :nodelist, :warnings
+    alias_method :options, :parse_context
+    include ParserSwitching
 
     class << self
-      def parse(tag_name, markup, tokens, options)
+      def parse(tag_name, markup, tokenizer, parse_context)
-        tag = new(tag_name, markup, options)
+        tag = new(tag_name, markup, parse_context)
-        tag.parse(tokens)
+        tag.parse(tokenizer)
         tag
       end
 
-      private :new
+      def disable_tags(*tags)
+        disabled_tags.push(*tags)
+      end
+
+      def disabled_tags
+        @disabled_tags ||= []
+      end
     end
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, parse_context)
       @tag_name   = tag_name
       @markup     = markup
-      @options    = options
+      @parse_context = parse_context
+      @line_number = parse_context.line_number
     end
 
-    def parse(tokens)
+    def parse(_tokens)
+    end
+
+    def raw
+      "#{@tag_name} #{@markup}"
     end
 
     def name
       self.class.name.downcase
     end
 
-    def render(context)
+    def render(_context)
-      ''.freeze
+      ''
+    end
+
+    def disabled?(context)
+      context.registers[:disabled_tags].disabled?(tag_name)
+    end
+
+    def disabled_error_message
+      "#{tag_name} #{options[:locale].t('errors.disabled.tag')}"
+    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
 
-    def parse_with_selected_parser(markup)
+    def disabled_tags
-      case @options[:error_mode] || Template.error_mode
+      self.class.disabled_tags
-      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
-          @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.message << " in \"#{markup.strip}\"" 
-      raise e
     end
   end
 end

lib/liquid/tags/assign.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # Assign sets a variable in your template.
   #
   #   {% assign foo = 'monkey' %}
@@ -11,27 +12,53 @@ module Liquid
   class Assign < Tag
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
-    def initialize(tag_name, markup, options)
+    def self.syntax_error_translation_key
-      super
+      "errors.syntax.assign"
+    end
+
+    attr_reader :to, :from
+
+    def parse(_tokens)
       if markup =~ Syntax
-        @to = $1
+        @to = Regexp.last_match(1)
-        @from = Variable.new($2)
+        @from = Variable.new(Regexp.last_match(2), options)
       else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
       end
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       val = @from.render(context)
       context.scopes.last[@to] = val
-      context.increment_used_resources(:assign_score_current, val)
+      context.resource_limits.assign_score += assign_score_of(val)
-      ''.freeze
+      output
     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)
+  Template.register_tag('assign', Assign)
 end

lib/liquid/tags/break.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # Break tag to be used to break out of a for loop.
   #
   # == Basic Usage:
@@ -10,12 +11,10 @@ module Liquid
   #    {% endfor %}
   #
   class Break < Tag
-
     def interrupt
       BreakInterrupt.new
     end
-
   end
 
-  Template.register_tag('break'.freeze, Break)
+  Template.register_tag('break', Break)
 end

lib/liquid/tags/capture.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
@@ -11,22 +13,23 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    Syntax = /(\w+)/
+    Syntax = /(#{VariableSignature}+)/o
 
-    def initialize(tag_name, markup, options)
+    def parse(_tokens)
-      super
       if markup =~ Syntax
-        @to = $1
+        @to = Regexp.last_match(1)
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
+        raise SyntaxError, options[:locale].t("errors.syntax.capture")
       end
+      super
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
-      output = super
+      previous_output_size = output.bytesize
+      super
       context.scopes.last[@to] = output
-      context.increment_used_resources(:assign_score_current, output)
+      context.resource_limits.assign_score += (output.bytesize - previous_output_size)
-      ''.freeze
+      output
     end
 
     def blank?
@@ -34,5 +37,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('capture'.freeze, Capture)
+  Template.register_tag('capture', Capture)
 end

lib/liquid/tags/case.rb

@@ -1,79 +1,89 @@
+# frozen_string_literal: true
+
 module Liquid
   class Case < Block
     Syntax     = /(#{QuotedFragment})/o
     WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
 
-    def initialize(tag_name, markup, options)
+    attr_reader :blocks, :left
-      super
+
+    def parse(tokens)
       @blocks = []
 
       if markup =~ Syntax
-        @left = $1
+        @left = Expression.parse(Regexp.last_match(1))
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
+        raise SyntaxError, options[:locale].t("errors.syntax.case")
       end
+
+      body = BlockBody.new
+      body = @blocks.last.attachment while parse_body(body, tokens)
     end
 
     def nodelist
-      @blocks.map(&:attachment).flatten
+      @blocks.map(&:attachment)
     end
 
     def unknown_tag(tag, markup, tokens)
-      @nodelist = []
       case tag
-      when 'when'.freeze
+      when 'when'
         record_when_condition(markup)
-      when 'else'.freeze
+      when 'else'
         record_else_condition(markup)
       else
         super
       end
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
-      context.stack do
+      execute_else_block = true
-        execute_else_block = true
 
-        output = ''
+      @blocks.each do |block|
-        @blocks.each do |block|
+        if block.else?
-          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)
-          elsif block.evaluate(context)
+          execute_else_block = false
-            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
-        # Create a new nodelist and assign it to the new block
+        unless markup =~ WhenSyntax
-        if not markup =~ WhenSyntax
+          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
-          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
         end
 
-        markup = $2
+        markup = Regexp.last_match(2)
 
-        block = Condition.new(@left, '=='.freeze, $1)
+        block = Condition.new(@left, '==', Expression.parse(Regexp.last_match(1)))
-        block.attach(@nodelist)
+        block.attach(body)
-        @blocks.push(block)
+        @blocks << block
       end
     end
 
     def record_else_condition(markup)
-      if not markup.strip.empty?
+      unless markup.strip.empty?
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
+        raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else")
       end
 
       block = ElseCondition.new
-      block.attach(@nodelist)
+      block.attach(BlockBody.new)
       @blocks << block
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.left] + @node.blocks
+      end
+    end
   end
 
-  Template.register_tag('case'.freeze, Case)
+  Template.register_tag('case', Case)
 end

lib/liquid/tags/comment.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module Liquid
   class Comment < Block
-    def render(context)
+    def render_to_output_buffer(_context, output)
-      ''.freeze
+      output
     end
 
-    def unknown_tag(tag, markup, tokens)
+    def unknown_tag(_tag, _markup, _tokens)
     end
 
     def blank?
@@ -12,5 +14,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('comment'.freeze, Comment)
+  Template.register_tag('comment', Comment)
 end

lib/liquid/tags/continue.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
   # Continue tag to be used to break out of a for loop.
   #
@@ -14,5 +16,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('continue'.freeze, Continue)
+  Template.register_tag('continue', Continue)
 end

lib/liquid/tags/cycle.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
   # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
   #
@@ -15,32 +17,42 @@ module Liquid
     SimpleSyntax = /\A#{QuotedFragment}+/o
     NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
 
-    def initialize(tag_name, markup, options)
+    attr_reader :variables
-      super
+
+    def parse(_tokens)
       case markup
       when NamedSyntax
-        @variables = variables_from_string($2)
+        @variables = variables_from_string(Regexp.last_match(2))
-        @name = $1
+        @name = Expression.parse(Regexp.last_match(1))
       when SimpleSyntax
         @variables = variables_from_string(markup)
-        @name = "'#{@variables.to_s}'"
+        @name = @variables.to_s
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
+        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
       end
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
-      context.registers[:cycle] ||= Hash.new(0)
+      context.registers[:cycle] ||= {}
 
-      context.stack do
+      key = context.evaluate(@name)
-        key = context[@name]
+      iteration = context.registers[:cycle][key].to_i
-        iteration = context.registers[:cycle][key]
+
-        result = context[@variables[iteration]]
+      val = context.evaluate(@variables[iteration])
-        iteration += 1
+
-        iteration  = 0  if iteration >= @variables.size
+      if val.is_a?(Array)
-        context.registers[:cycle][key] = iteration
+        val = val.join
-        result
+      elsif !val.is_a?(String)
+        val = val.to_s
       end
+
+      output << val
+
+      iteration += 1
+      iteration  = 0 if iteration >= @variables.size
+      context.registers[:cycle][key] = iteration
+
+      output
     end
 
     private
@@ -48,9 +60,15 @@ module Liquid
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        $1 ? $1 : nil
+        Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
       end.compact
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        Array(@node.variables)
+      end
+    end
   end
 
   Template.register_tag('cycle', Cycle)

lib/liquid/tags/decrement.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # decrement is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
   #     multiple instantiations of the template.
@@ -19,20 +20,18 @@ module Liquid
   #    Hello: -3
   #
   class Decrement < Tag
-    def initialize(tag_name, markup, options)
+    def parse(_tokens)
-      super
       @variable = markup.strip
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       value = context.environments.first[@variable] ||= 0
-      value = value - 1
+      value -= 1
       context.environments.first[@variable] = value
-      value.to_s
+      output << value.to_s
+      output
     end
-
-    private
   end
 
-  Template.register_tag('decrement'.freeze, Decrement)
+  Template.register_tag('decrement', Decrement)
 end

lib/liquid/tags/echo.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Liquid
+  # Echo outputs an expression
+  #
+  #   {% echo monkey %}
+  #   {% echo user.name %}
+  #
+  # This is identical to variable output syntax, like {{ foo }}, but works
+  # inside {% liquid %} tags. The full syntax is supported, including filters:
+  #
+  #   {% echo user | link %}
+  #
+  class Echo < Tag
+    attr_reader :variable
+
+    def parse(_tokens)
+      @variable = Variable.new(markup, parse_context)
+    end
+
+    def render(context)
+      variable&.render_to_output_buffer(context, +'')
+    end
+  end
+
+  Template.register_tag('echo', Echo)
+end

lib/liquid/tags/for.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # "For" iterates over an array or collection.
   # Several useful variables are available to you within the loop.
   #
@@ -24,7 +25,7 @@ module Liquid
   #      {{ item.name }}
   #    {% end %}
   #
-  #  To reverse the for loop simply use {% for item in collection reversed %}
+  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
   #
   # == Available variables:
   #
@@ -42,134 +43,171 @@ 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
 
-    def initialize(tag_name, markup, options)
+    attr_reader :collection_name, :variable_name, :limit, :from
-      super
+
+    def parse(tokens)
+      @from = @limit = nil
       parse_with_selected_parser(markup)
-      @nodelist = @for_block = []
+      @for_block = BlockBody.new
+      @else_block = nil
+      return unless parse_body(@for_block, tokens)
+      parse_body(@else_block, tokens)
     end
 
     def nodelist
-      if @else_block
+      @else_block ? [@for_block, @else_block] : [@for_block]
-        @for_block + @else_block
-      else
-        @for_block
-      end
     end
 
     def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'.freeze
+      return super unless tag == 'else'
-      @nodelist = @else_block = []
+      @else_block = BlockBody.new
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
-      context.registers[:for] ||= Hash.new(0)
+      segment = collection_segment(context)
 
-      collection = context[@collection_name]
+      if segment.empty?
-      collection = collection.to_a if collection.is_a?(Range)
+        render_else(context, output)
-
-      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      return render_else(context) unless iterable?(collection)
-
-      from = if @attributes['offset'.freeze] == 'continue'.freeze
-        context.registers[:for][@name].to_i
       else
-        context[@attributes['offset'.freeze]].to_i
+        render_segment(context, output, segment)
       end
 
-      limit = context[@attributes['limit'.freeze]]
+      output
-      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 = $1
+        @variable_name = Regexp.last_match(1)
-        @collection_name = $2
+        collection_name = Regexp.last_match(2)
-        @name = "#{$1}-#{$2}"
+        @reversed = !!Regexp.last_match(3)
-        @reversed = $3
+        @name = "#{@variable_name}-#{collection_name}"
-        @attributes = {}
+        @collection_name = Expression.parse(collection_name)
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          set_attribute(key, value)
         end
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
+        raise SyntaxError, options[:locale].t("errors.syntax.for")
       end
     end
 
     def strict_parse(markup)
       p = Parser.new(markup)
       @variable_name = p.consume(:id)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze))  unless p.id?('in'.freeze)
+      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
-      @collection_name = p.expression
+      collection_name = p.expression
-      @name = "#{@variable_name}-#{@collection_name}"
+      @name = "#{@variable_name}-#{collection_name}"
-      @reversed = p.id?('reversed'.freeze)
+      @collection_name = Expression.parse(collection_name)
+      @reversed = p.id?('reversed')
 
-      @attributes = {}
       while p.look(:id) && p.look(:colon, 1)
-        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
+        unless (attribute = p.id?('limit') || p.id?('offset'))
-          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
+          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
         end
         p.consume
-        val = p.expression
+        set_attribute(attribute, p.expression)
-        @attributes[attribute] = val
       end
       p.consume(:end_of_string)
     end
 
     private
 
-    def render_else(context)
+    def collection_segment(context)
-      return @else_block ? [render_all(@else_block, context)] : ''.freeze
+      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 iterable?(collection)
+    def render_segment(context, output, segment)
-      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
+      for_stack = context.registers[:for_stack] ||= []
+      length = segment.length
+
+      context.stack do
+        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
+
+        for_stack.push(loop_vars)
+
+        begin
+          context['forloop'] = loop_vars
+
+          segment.each do |item|
+            context[@variable_name] = item
+            @for_block.render_to_output_buffer(context, output)
+            loop_vars.send(:increment!)
+
+            # Handle any interrupts if they exist.
+            next unless context.interrupt?
+            interrupt = context.pop_interrupt
+            break if interrupt.is_a?(BreakInterrupt)
+            next if interrupt.is_a?(ContinueInterrupt)
+          end
+        ensure
+          for_stack.pop
+        end
+      end
+
+      output
+    end
+
+    def set_attribute(key, expr)
+      case key
+      when 'offset'
+        @from = if expr == 'continue'
+          :continue
+        else
+          Expression.parse(expr)
+        end
+      when 'limit'
+        @limit = Expression.parse(expr)
+      end
+    end
+
+    def render_else(context, output)
+      if @else_block
+        @else_block.render_to_output_buffer(context, output)
+      else
+        output
+      end
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        (super + [@node.limit, @node.from, @node.collection_name]).compact
+      end
     end
   end
 
-  Template.register_tag('for'.freeze, For)
+  Template.register_tag('for', For)
 end

lib/liquid/tags/if.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
   # If is the conditional block
   #
@@ -12,95 +14,106 @@ 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)
+    BOOLEAN_OPERATORS = %w(and or).freeze
 
-    def initialize(tag_name, markup, options)
+    attr_reader :blocks
-      super
-      @blocks = []
-      push_block('if'.freeze, markup)
-    end
 
     def nodelist
-      @blocks.map(&:attachment).flatten
+      @blocks.map(&:attachment)
+    end
+
+    def parse(tokens)
+      @blocks = []
+      push_block('if', markup)
+      while parse_body(@blocks.last.attachment, tokens)
+      end
     end
 
     def unknown_tag(tag, markup, tokens)
-      if ['elsif'.freeze, 'else'.freeze].include?(tag)
+      if ['elsif', 'else'].include?(tag)
         push_block(tag, markup)
       else
         super
       end
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
-      context.stack do
+      @blocks.each do |block|
-        @blocks.each do |block|
+        if block.evaluate(context)
-          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)
+    def push_block(tag, markup)
-        block = if tag == 'else'.freeze
+      block = if tag == 'else'
-          ElseCondition.new
+        ElseCondition.new
-        else
+      else
-          parse_with_selected_parser(markup)
+        parse_with_selected_parser(markup)
-        end
-
-        @blocks.push(block)
-        @nodelist = block.attach(Array.new)
       end
 
-      def lax_parse(markup)
+      @blocks.push(block)
-        expressions = markup.scan(ExpressionsAndOperators).reverse
+      block.attach(BlockBody.new)
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift =~ Syntax
+    end
 
-        condition = Condition.new($1, $2, $3)
+    def lax_parse(markup)
+      expressions = markup.scan(ExpressionsAndOperators)
+      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
 
-        while not expressions.empty?
+      condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
-          operator = (expressions.shift).to_s.strip
 
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.shift.to_s =~ Syntax
+      until expressions.empty?
+        operator = expressions.pop.to_s.strip
 
-          new_condition = Condition.new($1, $2, $3)
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
-          new_condition.send(operator, condition)
-          condition = new_condition
-        end
 
-        condition
+        new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
+        new_condition.send(operator, condition)
+        condition = new_condition
       end
 
-      def strict_parse(markup)
+      condition
-        p = Parser.new(markup)
+    end
 
-        condition = parse_comparison(p)
+    def strict_parse(markup)
+      p = Parser.new(markup)
+      condition = parse_binary_comparisons(p)
+      p.consume(:end_of_string)
+      condition
+    end
 
-        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+    def parse_binary_comparisons(p)
-          new_cond = parse_comparison(p)
+      condition = parse_comparison(p)
-          new_cond.send(op, condition)
+      first_condition = condition
-          condition = new_cond
+      while (op = (p.id?('and') || p.id?('or')))
-        end
+        child_condition = parse_comparison(p)
-        p.consume(:end_of_string)
+        condition.send(op, child_condition)
-
+        condition = child_condition
-        condition
       end
+      first_condition
+    end
 
-      def parse_comparison(p)
+    def parse_comparison(p)
-        a = p.expression
+      a = Expression.parse(p.expression)
-        if op = p.consume?(:comparison)
+      if (op = p.consume?(:comparison))
-          b = p.expression
+        b = Expression.parse(p.expression)
-          Condition.new(a, op, b)
+        Condition.new(a, op, b)
-        else
+      else
-          Condition.new(a)
+        Condition.new(a)
-        end
       end
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.blocks
+      end
+    end
   end
 
-  Template.register_tag('if'.freeze, If)
+  Template.register_tag('if', If)
 end

lib/liquid/tags/ifchanged.rb

@@ -1,20 +1,19 @@
+# frozen_string_literal: true
+
 module Liquid
   class Ifchanged < Block
+    def render_to_output_buffer(context, output)
+      block_output = +''
+      super(context, block_output)
 
-    def render(context)
+      if block_output != context.registers[:ifchanged]
-      context.stack do
+        context.registers[:ifchanged] = block_output
-
+        output << block_output
-        output = render_all(@nodelist, context)
-
-        if output != context.registers[:ifchanged]
-          context.registers[:ifchanged] = output
-          output
-        else
-          ''.freeze
-        end
       end
+
+      output
     end
   end
 
-  Template.register_tag('ifchanged'.freeze, Ifchanged)
+  Template.register_tag('ifchanged', Ifchanged)
 end

lib/liquid/tags/include.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # Include allows templates to relate with other templates
   #
   # Simply include another template:
@@ -15,80 +16,89 @@ module Liquid
   #   {% include 'product' for products %}
   #
   class Include < Tag
-    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
+    SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    Syntax = SYNTAX
 
-    def initialize(tag_name, markup, options)
+    attr_reader :template_name_expr, :variable_name_expr, :attributes
-      super
 
-      if markup =~ Syntax
+    def parse(_tokens)
+      if markup =~ SYNTAX
 
-        @template_name = $1
+        template_name = Regexp.last_match(1)
-        @variable_name = $3
+        variable_name = Regexp.last_match(3)
-        @attributes    = {}
+
+        @alias_name = Regexp.last_match(5)
+        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
+        @template_name_expr = Expression.parse(template_name)
+        @attributes = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = Expression.parse(value)
         end
 
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
+        raise SyntaxError, options[:locale].t("errors.syntax.include")
       end
     end
 
-    def parse(tokens)
+    def render_to_output_buffer(context, output)
-    end
+      template_name = context.evaluate(@template_name_expr)
+      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
 
-    def render(context)
+      partial = PartialCache.load(
-      partial = load_cached_partial(context)
+        template_name,
-      variable = context[@variable_name || @template_name[1..-2]]
+        context: context,
+        parse_context: parse_context
+      )
 
-      context.stack do
+      context_variable_name = @alias_name || template_name.split('/').last
-        @attributes.each do |key, value|
-          context[key] = context[value]
-        end
 
-        context_variable_name = @template_name[1..-2].split('/'.freeze).last
+      variable = if @variable_name_expr
-        if variable.is_a?(Array)
+        context.evaluate(@variable_name_expr)
-          variable.collect do |var|
+      else
-            context[context_variable_name] = var
+        context.find_variable(template_name, raise_on_not_found: false)
-            partial.render(context)
+      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
-        else
-          context[context_variable_name] = variable
-          partial.render(context)
         end
+      ensure
+        context.template_name = old_template_name
+        context.partial = old_partial
       end
+
+      output
     end
 
-    private
+    alias_method :parse_context, :options
-      def load_cached_partial(context)
+    private :parse_context
-        cached_partials = context.registers[:cached_partials] || {}
-        template_name = context[@template_name]
 
-        if cached = cached_partials[template_name]
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-          return cached
+      def children
-        end
+        [
-        source = read_template_from_file_system(context)
+          @node.template_name_expr,
-        partial = Liquid::Template.parse(source)
+          @node.variable_name_expr,
-        cached_partials[template_name] = partial
+        ] + @node.attributes.values
-        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[@template_name])
-        when 2
-          file_system.read_template_file(context[@template_name], context)
-        else
-          raise ArgumentError, "file_system.read_template_file expects two parameters: (template_name, context)"
-        end
       end
+    end
   end
 
-  Template.register_tag('include'.freeze, Include)
+  Template.register_tag('include', Include)
 end

lib/liquid/tags/increment.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Liquid
   # increment is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
@@ -15,17 +17,18 @@ module Liquid
   #    Hello: 2
   #
   class Increment < Tag
-    def initialize(tag_name, markup, options)
+    def parse(_tokens)
-      super
       @variable = markup.strip
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       value = context.environments.first[@variable] ||= 0
       context.environments.first[@variable] = value + 1
-      value.to_s
+
+      output << value.to_s
+      output
     end
   end
 
-  Template.register_tag('increment'.freeze, Increment)
+  Template.register_tag('increment', Increment)
 end

lib/liquid/tags/raw.rb

@@ -1,22 +1,45 @@
+# frozen_string_literal: true
+
 module Liquid
   class Raw < Block
+    Syntax = /\A\s*\z/
     FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
 
     def parse(tokens)
-      @nodelist ||= []
+      ensure_valid_markup(tag_name, markup, parse_context)
-      @nodelist.clear
+      @body = +''
-      while token = tokens.shift
+      while (token = tokens.shift)
         if token =~ FullTokenPossiblyInvalid
-          @nodelist << $1 if $1 != "".freeze
+          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
-          if @block_delimiter == $2
+          return if block_delimiter == Regexp.last_match(2)
-            end_tag
-            return
-          end
         end
-        @nodelist << token if not token.empty?
+        @body << token unless token.empty?
+      end
+
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", 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 Syntax.match?(markup)
+        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args", tag: tag_name)
       end
     end
   end
 
-  Template.register_tag('raw'.freeze, Raw)
+  Template.register_tag('raw', Raw)
 end

lib/liquid/tags/render.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Render < Tag
+    SYNTAX = /(#{QuotedString}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+
+    disable_tags "include"
+
+    attr_reader :template_name_expr, :attributes
+
+    def parse(_tokens)
+      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
+
+      template_name = Regexp.last_match(1)
+      variable_name = Regexp.last_match(3)
+
+      @alias_name = Regexp.last_match(5)
+      @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
+      @template_name_expr = Expression.parse(template_name)
+
+      @attributes = {}
+      markup.scan(TagAttributes) do |key, value|
+        @attributes[key] = Expression.parse(value)
+      end
+    end
+
+    def render_to_output_buffer(context, output)
+      render_tag(context, output)
+    end
+
+    def render_tag(context, output)
+      # Though we evaluate this here we will only ever parse it as a string literal.
+      template_name = context.evaluate(@template_name_expr)
+      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
+
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context
+      )
+
+      context_variable_name = @alias_name || template_name.split('/').last
+
+      render_partial_func = ->(var) {
+        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
+        inner_context[context_variable_name] = var unless var.nil?
+        partial.render_to_output_buffer(inner_context, output)
+      }
+
+      variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
+      variable.is_a?(Array) ? variable.each(&render_partial_func) : render_partial_func.call(variable)
+
+      output
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.template_name_expr,
+        ] + @node.attributes.values
+      end
+    end
+  end
+
+  Template.register_tag('render', Render)
+end

lib/liquid/tags/table_row.rb

@@ -1,73 +1,67 @@
+# frozen_string_literal: true
+
 module Liquid
   class TableRow < Block
     Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
 
-    def initialize(tag_name, markup, options)
+    attr_reader :variable_name, :collection_name, :attributes
-      super
+
+    def parse(_tokens)
       if markup =~ Syntax
-        @variable_name = $1
+        @variable_name = Regexp.last_match(1)
-        @collection_name = $2
+        @collection_name = Expression.parse(Regexp.last_match(2))
         @attributes = {}
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = value
+          @attributes[key] = Expression.parse(value)
         end
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row".freeze))
+        raise SyntaxError, options[:locale].t("errors.syntax.table_row")
       end
+      super
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
-      collection = context[@collection_name] or return ''.freeze
+      (collection = context.evaluate(@collection_name)) || (return '')
 
-      from = @attributes['offset'.freeze] ? context[@attributes['offset'.freeze]].to_i : 0
+      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
-      to = @attributes['limit'.freeze] ? from + context[@attributes['limit'.freeze]].to_i : nil
+      to = @attributes.key?('limit') ? from + context.evaluate(@attributes['limit']).to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
 
       length = collection.length
 
-      cols = context[@attributes['cols'.freeze]].to_i
+      cols = context.evaluate(@attributes['cols']).to_i
 
-      row = 1
+      output << "<tr class=\"row1\">\n"
-      col = 0
-
-      result = "<tr class=\"row1\">\n"
       context.stack do
+        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
+        context['tablerowloop'] = tablerowloop
 
-        collection.each_with_index do |item, index|
+        collection.each do |item|
           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>'
 
-          col += 1
+          if tablerowloop.col_last && !tablerowloop.last
-
+            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
-          result << "<td class=\"col#{col}\">" << render_all(@nodelist, context) << '</td>'
-
-          if col == cols and (index != length - 1)
-            col  = 0
-            row += 1
-            result << "</tr>\n<tr class=\"row#{row}\">"
           end
 
+          tablerowloop.send(:increment!)
         end
       end
-      result << "</tr>\n"
+
-      result
+      output << "</tr>\n"
+      output
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        super + @node.attributes.values + [@node.collection_name]
+      end
     end
   end
 
-  Template.register_tag('tablerow'.freeze, TableRow)
+  Template.register_tag('tablerow', TableRow)
 end

lib/liquid/tags/unless.rb

@@ -1,31 +1,30 @@
-require File.dirname(__FILE__) + '/if'
+# frozen_string_literal: true
+
+require_relative 'if'
 
 module Liquid
   # Unless is a conditional just like 'if' but works on the inverse logic.
   #
-  #   {% unless x < 0 %} x is greater than zero {% end %}
+  #   {% unless x < 0 %} x is greater than zero {% endunless %}
   #
   class Unless < If
-    def render(context)
+    def render_to_output_buffer(context, output)
-      context.stack do
+      # First condition is interpreted backwards ( if not )
-
+      first_block = @blocks.first
-        # First condition is interpreted backwards ( if not )
+      unless first_block.evaluate(context)
-        first_block = @blocks.first
+        return first_block.attachment.render_to_output_buffer(context, output)
-        unless first_block.evaluate(context)
-          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 render_all(block.attachment, context)
-          end
-        end
-
-        ''.freeze
       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)
+        end
+      end
+
+      output
     end
   end
 
-  Template.register_tag('unless'.freeze, Unless)
+  Template.register_tag('unless', Unless)
 end

lib/liquid/template.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # Templates are central to liquid.
   # Interpretating templates is a two step process. First you compile the
   # source code you got. During compile time some extensive error checking is performed.
@@ -14,21 +15,21 @@ module Liquid
   #   template.render('user_name' => 'bob')
   #
   class Template
-    DEFAULT_OPTIONS = {
+    attr_accessor :root
-      :locale => I18n.new
+    attr_reader :resource_limits, :warnings
-    }
 
-    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.has_key?(tag_name)
+        return nil unless @tags.key?(tag_name)
         return @cache[tag_name] if Liquid.cache_classes
 
         lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
@@ -44,13 +45,19 @@ module Liquid
         @cache.delete(tag_name)
       end
 
+      def each(&block)
+        @tags.each(&block)
+      end
+
       private
 
       def lookup_class(name)
-        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
+        Object.const_get(name)
       end
     end
 
+    attr_reader :profiler
+
     class << self
       # Sets how strict the parser should be.
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
@@ -58,6 +65,17 @@ module Liquid
       # :strict will enforce correct syntax.
       attr_writer :error_mode
 
+      # Sets how strict the taint checker should be.
+      # :lax is the default, and ignores the taint flag completely
+      # :warn adds a warning, but does not interrupt the rendering
+      # :error raises an error when tainted output is used
+      attr_writer :taint_mode
+
+      attr_accessor :default_exception_renderer
+      Template.default_exception_renderer = lambda do |exception|
+        exception
+      end
+
       def file_system
         @@file_system
       end
@@ -74,8 +92,20 @@ module Liquid
         @tags ||= TagRegistry.new
       end
 
+      def add_register(name, klass)
+        registers[name.to_sym] = klass
+      end
+
+      def registers
+        @registers ||= {}
+      end
+
       def error_mode
-        @error_mode || :lax
+        @error_mode ||= :lax
+      end
+
+      def taint_mode
+        @taint_mode ||= :lax
       end
 
       # Pass a module with filter methods which should be available
@@ -84,31 +114,36 @@ module Liquid
         Strainer.global_filter(mod)
       end
 
+      def default_resource_limits
+        @default_resource_limits ||= {}
+      end
+
       # creates a new <tt>Template</tt> object from liquid source code
+      # To enable profiling, pass in <tt>profile: true</tt> as an option.
+      # See Liquid::Profiler for more information
       def parse(source, options = {})
         template = Template.new
         template.parse(source, options)
       end
     end
 
-    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
     def initialize
-      @resource_limits = {}
+      @rethrow_errors = false
+      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
-      @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
+      @options = options
-      @warnings = nil
+      @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
       self
     end
 
-    def warnings
-      return [] unless @root
-      @warnings ||= @root.warnings
-    end
-
     def registers
       @registers ||= {}
     end
@@ -130,6 +165,9 @@ module Liquid
     # if you use the same filters over and over again consider registering them globally
     # with <tt>Template.register_filter</tt>
     #
+    # if profiling was enabled in <tt>Template#parse</tt> then the resulting profiling information
+    # will be available via <tt>Template#profiler</tt>
+    #
     # Following options can be passed:
     #
     #  * <tt>filters</tt> : array with local filters
@@ -137,12 +175,16 @@ module Liquid
     #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return ''.freeze if @root.nil?
+      return '' if @root.nil?
 
       context = case args.first
       when Liquid::Context
         c = args.shift
-        c.rethrow_errors = true if @rethrow_errors
+
+        if @rethrow_errors
+          c.exception_renderer = ->(_e) { raise }
+        end
+
         c
       when Liquid::Drop
         drop = args.shift
@@ -155,29 +197,37 @@ module Liquid
         raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
       end
 
+      output = nil
+
+      context_register = context.registers.is_a?(StaticRegisters) ? context.registers.static : context.registers
+
       case args.last
       when Hash
         options = args.pop
+        output = options[:output] if options[:output]
 
-        if options[:registers].is_a?(Hash)
+        options[:registers]&.each do |key, register|
-          self.registers.merge!(options[:registers])
+          context_register[key] = register
         end
 
-        if options[:filters]
+        apply_options_to_context(context, options)
-          context.add_filters(options[:filters])
+      when Module, Array
-        end
-
-      when Module
-        context.add_filters(args.pop)
-      when Array
         context.add_filters(args.pop)
       end
 
+      Template.registers.each do |key, register|
+        context_register[key] = register
+      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.
-        result = @root.render(context)
+        with_profiling(context) do
-        result.respond_to?(:join) ? result.join : result
+          @root.render_to_output_buffer(context, output || +'')
+        end
       rescue Liquid::MemoryError => e
         context.handle_error(e)
       ensure
@@ -190,19 +240,39 @@ module Liquid
       render(*args)
     end
 
-    private
+    def render_to_output_buffer(context, output)
-
+      render(context, output: output)
-    # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
-    def tokenize(source)
-      source = source.source if source.respond_to?(:source)
-      return [] if source.to_s.empty?
-      tokens = 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
 
+    private
+
+    def tokenize(source)
+      Tokenizer.new(source, @line_numbers)
+    end
+
+    def with_profiling(context)
+      if @profiling && !context.partial
+        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
+
+        @profiler = Profiler.new(context.template_name)
+        @profiler.start
+
+        begin
+          yield
+        ensure
+          @profiler.stop
+        end
+      else
+        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

lib/liquid/tokenizer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Tokenizer
+    attr_reader :line_number, :for_liquid_tag
+
+    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
+      @source = source
+      @line_number = line_number || (line_numbers ? 1 : nil)
+      @for_liquid_tag = for_liquid_tag
+      @tokens = tokenize
+    end
+
+    def shift
+      (token = @tokens.shift) || return
+
+      if @line_number
+        @line_number += @for_liquid_tag ? 1 : token.count("\n")
+      end
+
+      token
+    end
+
+    private
+
+    def tokenize
+      return [] if @source.to_s.empty?
+
+      return @source.split("\n") if @for_liquid_tag
+
+      tokens = @source.split(TemplateParser)
+
+      # removes the rogue empty element at the beginning of the array
+      tokens.shift if tokens[0]&.empty?
+
+      tokens
+    end
+  end
+end

lib/liquid/usage.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Liquid
+  module Usage
+    def self.increment(name)
+    end
+  end
+end

lib/liquid/utils.rb

@@ -1,27 +1,26 @@
+# frozen_string_literal: true
+
 module Liquid
   module Utils
-
     def self.slice_collection(collection, from, to)
-      if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
+      if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
       else
         slice_collection_using_each(collection, from, to)
       end
     end
 
-    def self.non_blank_string?(collection)
-      collection.is_a?(String) && collection != ''.freeze
-    end
-
     def self.slice_collection_using_each(collection, from, to)
       segments = []
       index = 0
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      return [collection] if non_blank_string?(collection)
+      if collection.is_a?(String)
+        return collection.empty? ? [] : [collection]
+      end
+      return [] unless collection.respond_to?(:each)
 
       collection.each do |item|
-
         if to && to <= index
           break
         end
@@ -35,5 +34,52 @@ module Liquid
 
       segments
     end
+
+    def self.to_integer(num)
+      return num if num.is_a?(Integer)
+      num = num.to_s
+      begin
+        Integer(num)
+      rescue ::ArgumentError
+        raise Liquid::ArgumentError, "invalid integer"
+      end
+    end
+
+    def self.to_number(obj)
+      case obj
+      when Float
+        BigDecimal(obj.to_s)
+      when Numeric
+        obj
+      when String
+        /\A-?\d+\.\d+\z/.match?(obj.strip) ? BigDecimal(obj) : obj.to_i
+      else
+        if obj.respond_to?(:to_number)
+          obj.to_number
+        else
+          0
+        end
+      end
+    end
+
+    def self.to_date(obj)
+      return obj if obj.respond_to?(:strftime)
+
+      if obj.is_a?(String)
+        return nil if obj.empty?
+        obj = obj.downcase
+      end
+
+      case obj
+      when 'now', 'today'
+        Time.now
+      when /\A\d+\z/, Integer
+        Time.at(obj.to_i)
+      when String
+        Time.parse(obj)
+      end
+    rescue ::ArgumentError
+      nil
+    end
   end
 end

lib/liquid/variable.rb

@@ -1,5 +1,6 @@
-module Liquid
+# frozen_string_literal: true
 
+module Liquid
   # Holds variables. Variables are only loaded "just in time"
   # and are not evaluated as part of the render stage
   #
@@ -11,97 +12,158 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
+    FilterMarkupRegex = /#{FilterSeparator}\s*(.*)/om
-    EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
+    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    attr_accessor :filters, :name, :warnings
+    FilterArgsRegex = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
+    JustTagAttributes = /\A#{TagAttributes}\z/o
+    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
 
-    def initialize(markup, options = {})
+    attr_accessor :filters, :name, :line_number
+    attr_reader :parse_context
+    alias_method :options, :parse_context
+
+    include ParserSwitching
+
+    def initialize(markup, parse_context)
       @markup  = markup
       @name    = nil
-      @options = options || {}
+      @parse_context = parse_context
+      @line_number = parse_context.line_number
 
-      case @options[:error_mode] || Template.error_mode
+      parse_with_selected_parser(markup)
-      when :strict then strict_parse(markup)
+    end
-      when :lax    then lax_parse(markup)
+
-      when :warn
+    def raw
-        begin
+      @markup
-          strict_parse(markup)
+    end
-        rescue SyntaxError => e
+
-          @warnings ||= []
+    def markup_context(markup)
-          @warnings << e
+      "in \"{{#{markup}}}\""
-          lax_parse(markup)
-        end
-      end
     end
 
     def lax_parse(markup)
       @filters = []
-      if markup =~ /\s*(#{QuotedFragment})(.*)/om
+      return unless markup =~ MarkupWithQuotedFragment
-        @name = Regexp.last_match(1)
+
-        if Regexp.last_match(2) =~ /#{FilterSeparator}\s*(.*)/om
+      name_markup = Regexp.last_match(1)
-          filters = Regexp.last_match(1).scan(FilterParser)
+      filter_markup = Regexp.last_match(2)
-          filters.each do |f|
+      @name = Expression.parse(name_markup)
-            if f =~ /\s*(\w+)/
+      if filter_markup =~ FilterMarkupRegex
-              filtername = Regexp.last_match(1)
+        filters = Regexp.last_match(1).scan(FilterParser)
-              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
+        filters.each do |f|
-              @filters << [filtername, filterargs]
+          next unless f =~ /\w+/
-            end
+          filtername = Regexp.last_match(0)
-          end
+          filterargs = f.scan(FilterArgsRegex).flatten
+          @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
     end
 
     def strict_parse(markup)
-      # Very simple valid cases
-      if markup =~ EasyParse
-        @name = $1
-        @filters = []
-        return
-      end
-
       @filters = []
       p = Parser.new(markup)
-      # Could be just filters with no input
+
-      @name = p.look(:pipe) ? ''.freeze : p.expression
+      @name = Expression.parse(p.expression)
       while p.consume?(:pipe)
         filtername = p.consume(:id)
         filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << [filtername, filterargs]
+        @filters << parse_filter_expressions(filtername, filterargs)
       end
       p.consume(:end_of_string)
-    rescue SyntaxError => e
-      e.message << " in \"{{#{markup}}}\""
-      raise e
     end
 
     def parse_filterargs(p)
       # first argument
       filterargs = [p.argument]
       # followed by comma separated others
-      while p.consume?(:comma)
+      filterargs << p.argument while p.consume?(:comma)
-        filterargs << p.argument
-      end
       filterargs
     end
 
     def render(context)
-      return ''.freeze if @name.nil?
+      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
-      @filters.inject(context[@name]) do |output, filter|
+        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        filterargs = []
+        context.invoke(filter_name, output, *filter_args)
-        keyword_args = {}
+      end
-        filter[1].to_a.each do |a|
+
-          if matches = a.match(/\A#{TagAttributes}\z/o)
+      obj = context.apply_global_filter(obj)
-            keyword_args[matches[1]] = context[matches[2]]
+      taint_check(context, obj)
-          else
+      obj
-            filterargs << context[a]
+    end
-          end
+
+    def render_to_output_buffer(context, output)
+      obj = render(context)
+
+      if obj.is_a?(Array)
+        output << obj.join
+      elsif obj.nil?
+      else
+        output << obj.to_s
+      end
+
+      output
+    end
+
+    def disabled?(_context)
+      false
+    end
+
+    def disabled_tags
+      []
+    end
+
+    private
+
+    def parse_filter_expressions(filter_name, unparsed_args)
+      filter_args = []
+      keyword_args = nil
+      unparsed_args.each do |a|
+        if (matches = a.match(JustTagAttributes))
+          keyword_args ||= {}
+          keyword_args[matches[1]] = Expression.parse(matches[2])
+        else
+          filter_args << Expression.parse(a)
         end
-        filterargs << keyword_args unless keyword_args.empty?
+      end
-        begin
+      result = [filter_name, filter_args]
-          output = context.invoke(filter[0], output, *filterargs)
+      result << keyword_args if keyword_args
-        rescue FilterNotFound
+      result
-          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
+    end
+
+    def evaluate_filter_expressions(context, filter_args, filter_kwargs)
+      parsed_args = filter_args.map { |expr| context.evaluate(expr) }
+      if filter_kwargs
+        parsed_kwargs = {}
+        filter_kwargs.each do |key, expr|
+          parsed_kwargs[key] = context.evaluate(expr)
         end
+        parsed_args << parsed_kwargs
+      end
+      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
       end
     end
   end

lib/liquid/variable_lookup.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Liquid
+  class VariableLookup
+    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
+    COMMAND_METHODS = ['size', 'first', 'last'].freeze
+
+    attr_reader :name, :lookups
+
+    def self.parse(markup)
+      new(markup)
+    end
+
+    def initialize(markup)
+      lookups = markup.scan(VariableParser)
+
+      name = lookups.shift
+      if name =~ SQUARE_BRACKETED
+        name = Expression.parse(Regexp.last_match(1))
+      end
+      @name = name
+
+      @lookups = lookups
+      @command_flags = 0
+
+      @lookups.each_index do |i|
+        lookup = lookups[i]
+        if lookup =~ SQUARE_BRACKETED
+          lookups[i] = Expression.parse(Regexp.last_match(1))
+        elsif COMMAND_METHODS.include?(lookup)
+          @command_flags |= 1 << i
+        end
+      end
+    end
+
+    def evaluate(context)
+      name = context.evaluate(@name)
+      object = context.find_variable(name)
+
+      @lookups.each_index do |i|
+        key = context.evaluate(@lookups[i])
+
+        # 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)))
+
+          # if its a proc we will replace the entry with the proc
+          res = context.lookup_and_evaluate(object, key)
+          object = res.to_liquid
+
+          # Some special cases. If the part wasn't in square brackets and
+          # no key with the same name was found we interpret following calls
+          # as commands and call them on the current object
+        elsif @command_flags & (1 << i) != 0 && object.respond_to?(key)
+          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
+        else
+          return nil unless context.strict_variables
+          raise Liquid::UndefinedVariable, "undefined variable #{key}"
+        end
+
+        # If we are dealing with a drop here we have to
+        object.context = context if object.respond_to?(:context=)
+      end
+
+      object
+    end
+
+    def ==(other)
+      self.class == other.class && state == other.state
+    end
+
+    protected
+
+    def state
+      [@name, @lookups, @command_flags]
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.lookups
+      end
+    end
+  end
+end

lib/liquid/version.rb

@@ -1,4 +1,6 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 module Liquid
-  VERSION = "3.0.0"
+  VERSION = "4.0.3"
 end

liquid.gemspec

@@ -1,6 +1,8 @@
 # encoding: utf-8
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require "liquid/version"
 
@@ -9,20 +11,22 @@ 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 Luetke"]
+  s.authors     = ["Tobias Lütke"]
   s.email       = ["tobi@leetsoft.com"]
   s.homepage    = "http://www.liquidmarkup.org"
   s.license     = "MIT"
-  #s.description = "A secure, non-evaling end user template engine with aesthetic markup."
+  # s.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(MIT-LICENSE README.md)
+  s.files       = Dir.glob("{lib}/**/*") + %w(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'
+  s.add_development_dependency('rake', '~> 11.3')
+  s.add_development_dependency('minitest')
 end

performance/benchmark.rb

@@ -1,11 +1,20 @@
-require 'benchmark'
+# frozen_string_literal: true
-require File.dirname(__FILE__) + '/theme_runner'
+
+require 'benchmark/ips'
+require_relative 'theme_runner'
 
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
-Benchmark.bmbm do |x|
+Benchmark.ips do |x|
-  x.report("parse:")   { 100.times { profiler.compile } }
+  x.time = 10
-  x.report("parse & run:")   { 100.times { profiler.run } }
+  x.warmup = 5
-end
 
+  puts
+  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
+  puts
+
+  x.report("parse:") { profiler.compile }
+  x.report("render:") { profiler.render }
+  x.report("parse & render:") { profiler.run }
+end

performance/memory_profile.rb

@@ -0,0 +1,63 @@
+# 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

performance/profile.rb

@@ -1,17 +1,26 @@
-require 'stackprof' rescue fail("install stackprof extension/gem")
+# frozen_string_literal: true
-require File.dirname(__FILE__) + '/theme_runner'
+
+require 'stackprof'
+require_relative 'theme_runner'
 
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run
 
 [:cpu, :object].each do |profile_type|
-  puts "Profiling in #{profile_type.to_s} mode..."
+  puts "Profiling in #{profile_type} mode..."
   results = StackProf.run(mode: profile_type) do
-    100.times do
+    200.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

performance/shopify/comment_form.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class CommentForm < Liquid::Block
   Syntax = /(#{Liquid::VariableSignature}+)/
 
@@ -5,14 +7,14 @@ class CommentForm < Liquid::Block
     super
 
     if markup =~ Syntax
-      @variable_name = $1
+      @variable_name = Regexp.last_match(1)
       @attributes = {}
     else
-      raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
+      raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]"
     end
   end
 
-  def render(context)
+  def render_to_output_buffer(context, output)
     article = context[@variable_name]
 
     context.stack do
@@ -20,14 +22,16 @@ class CommentForm < Liquid::Block
         'posted_successfully?' => context.registers[:posted_successfully],
         'errors' => context['comment.errors'],
         'author' => context['comment.author'],
-        'email'  => context['comment.email'],
+        'email' => context['comment.email'],
-        'body'   => context['comment.body']
+        'body' => context['comment.body'],
       }
-      wrap_in_form(article, render_all(@nodelist, context))
+
+      output << wrap_in_form(article, render_all(@nodelist, context, output))
+      output
     end
   end
 
   def wrap_in_form(article, input)
-    %Q{<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>}
+    %(<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>)
   end
 end

performance/shopify/database.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'yaml'
 
 module Database
@@ -5,7 +7,7 @@ module Database
   # to liquid as assigns. All this is based on Shopify
   def self.tables
     @tables ||= begin
-      db = YAML.load_file(File.dirname(__FILE__) + '/vision.database.yml')
+      db = YAML.load_file("#{__dir__}/vision.database.yml")
 
       # From vision source
       db['products'].each do |product|
@@ -16,9 +18,10 @@ module Database
       end
 
       # key the tables by handles, as this is how liquid expects it.
-      db = db.inject({}) do |assigns, (key, values)|
+      db = db.each_with_object({}) do |(key, values), assigns|
-        assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; }
+        assigns[key] = values.each_with_object({}) do |v, h|
-        assigns
+          h[v['handle']] = v
+        end
       end
 
       # Some standard direct accessors so that the specialized templates
@@ -29,9 +32,9 @@ module Database
       db['article']    = db['blog']['articles'].first
 
       db['cart']       = {
-        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
+        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum + item['line_price'] * item['quantity'] },
-        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
+        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum + item['quantity'] },
-        'items'       => db['line_items'].values
+        'items' => db['line_items'].values,
       }
 
       db
@@ -39,7 +42,7 @@ module Database
   end
 end
 
-if __FILE__ == $0
+if __FILE__ == $PROGRAM_NAME
-  p Database.tables['collections']['frontpage'].keys
+  p(Database.tables['collections']['frontpage'].keys)
-  #p Database.tables['blog']['articles']
+  # p Database.tables['blog']['articles']
 end

performance/shopify/json_filter.rb

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 require 'json'
 
 module JsonFilter
-
   def json(object)
-    JSON.dump(object.reject {|k,v| k == "collections" })
+    JSON.dump(object.reject { |k, _v| k == "collections" })
   end
-
 end

performance/shopify/liquid.rb

@@ -1,19 +1,21 @@
-$:.unshift File.dirname(__FILE__) + '/../../lib'
+# frozen_string_literal: true
-require File.dirname(__FILE__) + '/../../lib/liquid'
 
-require File.dirname(__FILE__) + '/comment_form'
+$LOAD_PATH.unshift(__dir__ + '/../../lib')
-require File.dirname(__FILE__) + '/paginate'
+require_relative '../../lib/liquid'
-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
+require_relative 'comment_form'
-Liquid::Template.register_tag 'form', CommentForm
+require_relative 'paginate'
+require_relative 'json_filter'
+require_relative 'money_filter'
+require_relative 'shop_filter'
+require_relative 'tag_filter'
+require_relative 'weight_filter'
 
-Liquid::Template.register_filter JsonFilter
+Liquid::Template.register_tag('paginate', Paginate)
-Liquid::Template.register_filter MoneyFilter
+Liquid::Template.register_tag('form', CommentForm)
-Liquid::Template.register_filter WeightFilter
+
-Liquid::Template.register_filter ShopFilter
+Liquid::Template.register_filter(JsonFilter)
-Liquid::Template.register_filter TagFilter
+Liquid::Template.register_filter(MoneyFilter)
+Liquid::Template.register_filter(WeightFilter)
+Liquid::Template.register_filter(ShopFilter)
+Liquid::Template.register_filter(TagFilter)

performance/shopify/money_filter.rb

@@ -1,13 +1,14 @@
-module MoneyFilter
+# frozen_string_literal: true
 
+module MoneyFilter
   def money_with_currency(money)
     return '' if money.nil?
-    sprintf("$ %.2f USD", money/100.0)
+    format("$ %.2f USD", money / 100.0)
   end
 
   def money(money)
     return '' if money.nil?
-    sprintf("$ %.2f", money/100.0)
+    format("$ %.2f", money / 100.0)
   end
 
   private

performance/shopify/paginate.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 class Paginate < Liquid::Block
-  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
 
   def initialize(tag_name, markup, options)
     super
 
-    @nodelist = []
-
     if markup =~ Syntax
-      @collection_name = $1
+      @collection_name = Regexp.last_match(1)
-      @page_size = if $2
+      @page_size = if Regexp.last_match(2)
-        $3.to_i
+        Regexp.last_match(3).to_i
       else
         20
       end
@@ -19,48 +19,47 @@ class Paginate < Liquid::Block
         @attributes[key] = value
       end
     else
-      raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
+      raise SyntaxError, "Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number"
     end
   end
 
-  def render(context)
+  def render_to_output_buffer(context, output)
     @context = context
 
     context.stack do
-      current_page  = context['current_page'].to_i
+      current_page = context['current_page'].to_i
 
       pagination = {
-        'page_size'      => @page_size,
+        'page_size' => @page_size,
-        'current_page'   => 5,
+        'current_page' => 5,
-        'current_offset' => @page_size * 5
+        'current_offset' => @page_size * 5,
       }
 
       context['paginate'] = pagination
 
-      collection_size  = context[@collection_name].size
+      collection_size = context[@collection_name].size
 
-      raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection_size.nil?
+      raise ArgumentError, "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['pages']      = page_count - 1
-      pagination['previous']   = link('&laquo; Previous', current_page-1 )  unless 1 >= current_page
+      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['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'] or page >= current_page + @attributes['window_size']
+          elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
             next if hellip_break
             pagination['parts'] << no_link('&hellip;')
             hellip_break = true
@@ -73,18 +72,18 @@ class Paginate < Liquid::Block
         end
       end
 
-      render_all(@nodelist, context)
+      super
     end
   end
 
   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

performance/shopify/shop_filter.rb

@@ -1,5 +1,6 @@
-module ShopFilter
+# frozen_string_literal: true
 
+module ShopFilter
   def asset_url(input)
     "/files/1/[shop_id]/[shop_id]/assets/#{input}"
   end
@@ -16,21 +17,21 @@ module ShopFilter
     %(<script src="#{url}" type="text/javascript"></script>)
   end
 
-  def stylesheet_tag(url, media="all")
+  def stylesheet_tag(url, media = "all")
     %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
   end
 
-  def link_to(link, url, title="")
+  def link_to(link, url, title = "")
-    %|<a href="#{url}" title="#{title}">#{link}</a>|
+    %(<a href="#{url}" title="#{title}">#{link}</a>)
   end
 
-  def img_tag(url, alt="")
+  def img_tag(url, alt = "")
-    %|<img src="#{url}" alt="#{alt}" />|
+    %(<img src="#{url}" alt="#{alt}" />)
   end
 
   def link_to_vendor(vendor)
     if vendor
-      link_to vendor, url_for_vendor(vendor), vendor
+      link_to(vendor, url_for_vendor(vendor), vendor)
     else
       'Unknown Vendor'
     end
@@ -38,7 +39,7 @@ module ShopFilter
 
   def link_to_type(type)
     if type
-      link_to type, url_for_type(type), type
+      link_to(type, url_for_type(type), type)
     else
       'Unknown Vendor'
     end
@@ -53,8 +54,7 @@ module ShopFilter
   end
 
   def product_img_url(url, style = 'small')
-
+    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
-    unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
       raise ArgumentError, 'filter "size" can only be called on product images'
     end
 
@@ -62,27 +62,24 @@ module ShopFilter
     when 'original'
       return '/files/shops/random_number/' + url
     when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"
+      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(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']
 
-    for part in paginate['parts']
+    paginate['parts'].each do |part|
-
+      html << if part['is_link']
-      if part['is_link']
+        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
-        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
       elsif part['title'].to_i == paginate['current_page'].to_i
-        html << %(<span class="page current">#{part['title']}</span>)
+        %(<span class="page current">#{part['title']}</span>)
       else
-        html << %(<span class="deco">#{part['title']}</span>)
+        %(<span class="deco">#{part['title']}</span>)
       end
-
     end
 
     html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
@@ -106,5 +103,4 @@ module ShopFilter
     result.gsub!(/\A-+/, '') if result[0] == '-'
     result
   end
-
 end

performance/shopify/tag_filter.rb

@@ -1,10 +1,11 @@
-module TagFilter
+# frozen_string_literal: true
 
+module TagFilter
   def link_to_tag(label, tag)
     "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
   end
 
-  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
@@ -14,12 +15,11 @@ module TagFilter
 
   def link_to_add_tag(label, tag)
     tags = (@context['current_tags'] + [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
   end
 
   def link_to_remove_tag(label, tag)
     tags = (@context['current_tags'] - [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
   end
-
 end

performance/shopify/weight_filter.rb

@@ -1,11 +1,11 @@
-module WeightFilter
+# frozen_string_literal: true
 
+module WeightFilter
   def weight(grams)
-    sprintf("%.2f", grams / 1000)
+    format("%.2f", grams / 1000)
   end
 
   def weight_with_unit(grams)
     "#{weight(grams)} kg"
   end
-
 end

performance/theme_runner.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This profiler run simulates Shopify.
 # We are looking in the tests directory for liquid files and render them within the designated layout file.
 # We will also export a substantial database to liquid which the templates can render values of.
@@ -6,73 +8,115 @@
 # 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 File.dirname(__FILE__) + '/shopify/liquid'
+require_relative 'shopify/liquid'
-require File.dirname(__FILE__) + '/shopify/database.rb'
+require_relative 'shopify/database'
 
 class ThemeRunner
   class FileSystem
-
     def initialize(path)
       @path = path
     end
 
     # Called by Liquid to retrieve a template file
-    def read_template_file(template_path, context)
+    def read_template_file(template_path)
       File.read(@path + '/' + template_path + '.liquid')
     end
   end
 
-  # Load all templates into memory, do this now so that
+  # Initialize a new liquid ThemeRunner instance
-  # we don't profile IO.
+  # Will load all templates into memory, do this now so that we don't profile IO.
   def initialize
-    @tests = Dir[File.dirname(__FILE__) + '/tests/**/*.liquid'].collect do |test|
+    @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
       next if File.basename(test) == 'theme.liquid'
 
       theme_path = File.dirname(test) + '/theme.liquid'
-
+      {
-      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
+        liquid: File.read(test),
+        layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
+        template_name: test,
+      }
     end.compact
+
+    compile_all_tests
   end
 
+  # `compile` will test just the compilation portion of liquid without any templates
   def compile
-    # Dup assigns because will make some changes to them
+    @tests.each do |test_hash|
-
+      Liquid::Template.new.parse(test_hash[:liquid])
-    @tests.each do |liquid, layout, template_name|
+      Liquid::Template.new.parse(test_hash[:layout])
-
-      tmpl = Liquid::Template.new
-      tmpl.parse(liquid)
-      tmpl = Liquid::Template.new
-      tmpl.parse(layout)
     end
   end
 
-   def run
+  # `run` is called to benchmark rendering and compiling at the same time
+  def run
+    each_test do |liquid, layout, assigns, page_template, template_name|
+      compile_and_render(liquid, layout, assigns, page_template, template_name)
+    end
+  end
+
+  # `render` is called to benchmark just the render portion of liquid
+  def render
+    @compiled_tests.each do |test|
+      tmpl = test[:tmpl]
+      assigns = test[:assigns]
+      layout = test[:layout]
+
+      if layout
+        assigns['content_for_layout'] = tmpl.render!(assigns)
+        layout.render!(assigns)
+      else
+        tmpl.render!(assigns)
+      end
+    end
+  end
+
+  private
+
+  def compile_and_render(template, layout, assigns, page_template, template_file)
+    compiled_test = compile_test(template, layout, assigns, page_template, template_file)
+    assigns['content_for_layout'] = compiled_test[:tmpl].render!(assigns)
+    compiled_test[:layout].render!(assigns) if layout
+  end
+
+  def compile_all_tests
+    @compiled_tests = []
+    each_test do |liquid, layout, assigns, page_template, template_name|
+      @compiled_tests << compile_test(liquid, layout, assigns, page_template, template_name)
+    end
+    @compiled_tests
+  end
+
+  def compile_test(template, layout, assigns, page_template, template_file)
+    tmpl = init_template(page_template, template_file)
+    parsed_template = tmpl.parse(template).dup
+
+    if layout
+      parsed_layout = tmpl.parse(layout)
+      { tmpl: parsed_template, assigns: assigns, layout: parsed_layout }
+    else
+      { tmpl: parsed_template, assigns: assigns }
+    end
+  end
+
+  # utility method with similar functionality needed in `compile_all_tests` and `run`
+  def each_test
     # Dup assigns because will make some changes to them
     assigns = Database.tables.dup
 
-    @tests.each do |liquid, layout, template_name|
+    @tests.each do |test_hash|
-
+      # Compute page_template outside of profiler run, uninteresting to profiler
-      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      page_template = File.basename(test_hash[:template_name], File.extname(test_hash[:template_name]))
-      page_template = File.basename(template_name, File.extname(template_name))
+      yield(test_hash[:liquid], test_hash[:layout], assigns, page_template, test_hash[: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 compile_and_render(template, layout, assigns, page_template, template_file)
+  def init_template(page_template, template_file)
     tmpl = Liquid::Template.new
     tmpl.assigns['page_title'] = 'Page title'
     tmpl.assigns['template'] = page_template
     tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
-
+    tmpl
-    content_for_layout = tmpl.parse(template).render!(assigns)
-
-    if layout
-      assigns['content_for_layout'] = content_for_layout
-      tmpl.parse(layout).render!(assigns)
-    else
-      content_for_layout
-    end
   end
 end

test/integration/assign_test.rb

@@ -1,27 +1,50 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-class AssignTest < Test::Unit::TestCase
+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] }}.',
+      '{% assign foo = values %}.{{ foo[0] }}.',
-                           'values' => %w{foo bar baz})
+      'values' => %w(foo bar baz))
 
     assert_template_result('.bar.',
-                           '{% assign foo = values %}.{{ foo[1] }}.',
+      '{% assign foo = values %}.{{ foo[1] }}.',
-                           'values' => %w{foo bar baz})
+      'values' => %w(foo bar baz))
   end
 
   def test_assign_with_filter
     assert_template_result('.bar.',
-                           '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
+      '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
-                           'values' => "foo,bar,baz")
+      'values' => "foo,bar,baz")
   end
 
   def test_assign_syntax_error
     assert_match_syntax_error(/assign/,
-                       '{% assign foo not values %}.',
+      '{% assign foo not values %}.',
-                       'values' => "foo,bar,baz")
+      'values' => "foo,bar,baz")
+  end
+
+  def test_assign_uses_error_mode
+    with_error_mode(:strict) do
+      assert_raises(SyntaxError) do
+        Template.parse("{% assign foo = ('X' | downcase) %}")
+      end
+    end
+    with_error_mode(:lax) do
+      assert Template.parse("{% assign foo = ('X' | downcase) %}")
+    end
   end
 end # AssignTest

test/integration/blank_test.rb

@@ -1,20 +1,21 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class FoobarTag < Liquid::Tag
-  def render(*args)
+  def render_to_output_buffer(_context, output)
-    " "
+    output << ' '
+    output
   end
-
-  Liquid::Template.register_tag('foobar', FoobarTag)
 end
 
 class BlankTestFileSystem
-  def read_template_file(template_path, context)
+  def read_template_file(template_path)
     template_path
   end
 end
 
-class BlankTest < Test::Unit::TestCase
+class BlankTest < Minitest::Test
   include Liquid
   N = 10
 
@@ -31,7 +32,9 @@ class BlankTest < Test::Unit::TestCase
   end
 
   def test_new_tags_are_not_blank_by_default
-    assert_template_result(" "*N, wrap_in_for("{% foobar %}"))
+    with_custom_tag('foobar', FoobarTag) do
+      assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
+    end
   end
 
   def test_loops_are_blank
@@ -47,7 +50,7 @@ class BlankTest < Test::Unit::TestCase
   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
@@ -60,9 +63,9 @@ class BlankTest < Test::Unit::TestCase
 
   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),
+    assert_template_result("\n       but this is not " * (N + 1),
-      wrap(%q{{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
+      wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
-      {% if true %} but this is not {% endif %}}))
+      {% if true %} but this is not {% endif %}'))
   end
 
   def test_assigns_are_blank
@@ -76,31 +79,31 @@ class BlankTest < Test::Unit::TestCase
 
   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 " foobar "*(N+1), wrap("{% include ' foobar ' %}")
+    assert_template_result(" foobar " * (N + 1), wrap("{% include ' foobar ' %}"))
-    assert_template_result "   "*(N+1), wrap(" {% include ' ' %} ")
+    assert_template_result("   " * (N + 1), wrap(" {% include ' ' %} "))
   end
 
   def test_case_is_blank
     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

test/integration/block_test.rb

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

test/integration/capture_test.rb

@@ -1,12 +1,24 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-class CaptureTest < Test::Unit::TestCase
+class CaptureTest < Minitest::Test
   include Liquid
 
   def test_captures_block_content_in_variable
     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 = '' %}
@@ -20,7 +32,7 @@ class CaptureTest < Test::Unit::TestCase
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal "test-string", rendered.gsub(/\s/, '')
+    assert_equal("test-string", rendered.gsub(/\s/, ''))
   end
 
   def test_assigning_from_capture
@@ -35,6 +47,6 @@ class CaptureTest < Test::Unit::TestCase
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal "3-3", rendered.gsub(/\s/, '')
+    assert_equal("3-3", rendered.gsub(/\s/, ''))
   end
 end # CaptureTest

test/integration/context_test.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-class ContextTest < Test::Unit::TestCase
+class ContextTest < Minitest::Test
   include Liquid
 
   def test_override_global_filter
@@ -16,18 +18,17 @@ class ContextTest < Test::Unit::TestCase
       end
     end
 
-    Template.register_filter(global)
+    with_global_filter(global) do
-    assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
+      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
-    Template.error_mode = :strict
+    with_error_mode :strict do
-
+      context = Context.new
-    context = Context.new
+      context.key?('unknown')
-
+      assert_empty context.errors
-    context.has_key?('unknown')
+    end
-
-    assert_empty context.errors
   end
 end

test/integration/document_test.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+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

test/integration/drop_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 class ContextDrop < Liquid::Drop
@@ -13,13 +15,12 @@ class ContextDrop < Liquid::Drop
     @context['forloop.index']
   end
 
-  def before_method(method)
+  def liquid_method_missing(method)
-    return @context[method]
+    @context[method]
   end
 end
 
 class ProductDrop < Liquid::Drop
-
   class TextDrop < Liquid::Drop
     def array
       ['text1', 'text2']
@@ -31,8 +32,8 @@ class ProductDrop < Liquid::Drop
   end
 
   class CatchallDrop < Liquid::Drop
-    def before_method(method)
+    def liquid_method_missing(method)
-      return 'method: ' << method.to_s
+      "catchall_method: #{method}"
     end
   end
 
@@ -48,14 +49,19 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
+  def user_input
+    (+"foo").taint
+  end
+
   protected
-    def callmenot
+
-      "protected"
+  def callmenot
-    end
+    "protected"
+  end
 end
 
 class EnumerableDrop < Liquid::Drop
-  def before_method(method)
+  def liquid_method_missing(method)
     method
   end
 
@@ -89,7 +95,7 @@ end
 class RealEnumerableDrop < Liquid::Drop
   include Enumerable
 
-  def before_method(method)
+  def liquid_method_missing(method)
     method
   end
 
@@ -100,63 +106,92 @@ class RealEnumerableDrop < Liquid::Drop
   end
 end
 
-class DropsTest < Test::Unit::TestCase
+class DropsTest < Minitest::Test
   include Liquid
 
   def test_product_drop
-    assert_nothing_raised do
+    tpl = Liquid::Template.parse('  ')
-      tpl = Liquid::Template.parse( '  '  )
+    assert_equal('  ', tpl.render!('product' => ProductDrop.new))
+  end
+
+  def test_rendering_raises_on_tainted_attr
+    with_taint_mode(:error) do
+      tpl = Liquid::Template.parse('{{ product.user_input }}')
+      assert_raises TaintedError do
+        tpl.render!('product' => ProductDrop.new)
+      end
+    end
+  end
+
+  def test_rendering_warns_on_tainted_attr
+    with_taint_mode(:warn) do
+      tpl = Liquid::Template.parse('{{ product.user_input }}')
+      context = Context.new('product' => ProductDrop.new)
+      tpl.render!(context)
+      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+      assert_equal "variable 'product.user_input' is tainted and was not escaped", context.warnings.first.to_s(false)
+    end
+  end
+
+  def test_rendering_doesnt_raise_on_escaped_tainted_attr
+    with_taint_mode(:error) do
+      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
       tpl.render!('product' => ProductDrop.new)
     end
   end
 
   def test_drop_does_only_respond_to_whitelisted_methods
-    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
+    assert_equal("", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new))
-    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)
+    assert_equal("", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new))
-    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new)
+    assert_equal("", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new))
-    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal("", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new))
-    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal("", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new))
-    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
+    assert_equal("", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new))
   end
 
   def test_drops_respond_to_to_liquid
-    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new)
+    assert_equal("text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new))
-    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
+    assert_equal("text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new))
   end
 
   def test_text_drop
-    output = Liquid::Template.parse( ' {{ product.texts.text }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
-    assert_equal ' text1 ', output
+    assert_equal(' text1 ', output)
   end
 
-  def test_unknown_method
+  def test_catchall_unknown_method
-    output = Liquid::Template.parse( ' {{ product.catchall.unknown }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
-    assert_equal ' method: unknown ', output
+    assert_equal(' catchall_method: unknown ', output)
   end
 
-  def test_integer_argument_drop
+  def test_catchall_integer_argument_drop
-    output = Liquid::Template.parse( ' {{ product.catchall[8] }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
-    assert_equal ' method: 8 ', output
+    assert_equal(' catchall_method: 8 ', output)
   end
 
   def test_text_array_drop
-    output = Liquid::Template.parse( '{% for text in product.texts.array %} {{text}} {% endfor %}'  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
-    assert_equal ' text1  text2 ', output
+    assert_equal(' text1  text2 ', output)
   end
 
   def test_context_drop
-    output = Liquid::Template.parse( ' {{ context.bar }} '  ).render!('context' => ContextDrop.new, 'bar' => "carrot")
+    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
-    assert_equal ' carrot ', output
+    assert_equal(' carrot ', output)
+  end
+
+  def test_context_drop_array_with_map
+    output = Liquid::Template.parse(' {{ contexts | map: "bar" }} ').render!('contexts' => [ContextDrop.new, ContextDrop.new], 'bar' => "carrot")
+    assert_equal(' carrotcarrot ', output)
   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
+    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
+    assert_equal('  ', output)
   end
 
   def test_object_methods_not_allowed
@@ -167,43 +202,43 @@ class DropsTest < Test::Unit::TestCase
   end
 
   def test_scope
-    assert_equal '1', Liquid::Template.parse( '{{ context.scopes }}'  ).render!('context' => ContextDrop.new)
+    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('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('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.new{|c| c['context.scopes'] })
+    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.new{|c| c['context.scopes'] }, 'dummy' => [1])
+    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.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 { |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"%}{{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('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 '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('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('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('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_before_method_for_clashing_method_names
+  def test_enumerable_drop_will_invoke_liquid_method_missing_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)
@@ -213,16 +248,16 @@ class DropsTest < Test::Unit::TestCase
   end
 
   def test_some_enumerable_methods_still_get_invoked
-    [ :count, :max ].each do |method|
+    [:count, :max].each do |method|
       assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
       assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
       assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
       assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
     end
 
-    assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)
+    assert_equal("yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new))
 
-    [ :min, :first ].each do |method|
+    [:min, :first].each do |method|
       assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
       assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
       assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
@@ -231,15 +266,22 @@ class DropsTest < Test::Unit::TestCase
   end
 
   def test_empty_string_value_access
-    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => '')
+    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => ''))
   end
 
   def test_nil_value_access
-    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil)
+    assert_equal('', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil))
   end
 
   def test_default_to_s_on_drops
-    assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
+    assert_equal('ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new))
-    assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
+    assert_equal('EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new))
+  end
+
+  def test_invokable_methods
+    assert_equal(%w(to_liquid catchall user_input context texts).to_set, ProductDrop.invokable_methods)
+    assert_equal(%w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods)
+    assert_equal(%w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods)
+    assert_equal(%w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods)
   end
 end # DropsTest

test/integration/error_handling_test.rb

@@ -1,110 +1,263 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-class ErrorDrop < Liquid::Drop
+class ErrorHandlingTest < Minitest::Test
-  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 < Test::Unit::TestCase
   include Liquid
 
-  def test_standard_error
+  def test_templates_parsed_with_line_numbers_renders_them_in_errors
-    assert_nothing_raised do
+    template = <<-LIQUID
-      template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
+      Hello,
-      assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
 
-      assert_equal 1, template.errors.size
+      {{ errors.standard_error }} will raise a standard error.
-      assert_equal StandardError, template.errors.first.class
+
-    end
+      Bla bla test.
+
+      {{ errors.syntax_error }} will raise a syntax error.
+
+      This is an argument error: {{ errors.argument_error }}
+
+      Bla.
+    LIQUID
+
+    expected = <<-TEXT
+      Hello,
+
+      Liquid error (line 3): standard error will raise a standard error.
+
+      Bla bla test.
+
+      Liquid syntax error (line 7): syntax error will raise a syntax error.
+
+      This is an argument error: Liquid error (line 9): argument error
+
+      Bla.
+    TEXT
+
+    output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
+    assert_equal(expected, output)
+  end
+
+  def test_standard_error
+    template = Liquid::Template.parse(' {{ errors.standard_error }} ')
+    assert_equal(' Liquid error: standard error ', template.render('errors' => ErrorDrop.new))
+
+    assert_equal(1, template.errors.size)
+    assert_equal(StandardError, template.errors.first.class)
   end
 
   def test_syntax
+    template = Liquid::Template.parse(' {{ errors.syntax_error }} ')
+    assert_equal(' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new))
 
-    assert_nothing_raised do
+    assert_equal(1, template.errors.size)
-
+    assert_equal(SyntaxError, template.errors.first.class)
-      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
-      assert_equal SyntaxError, template.errors.first.class
-
-    end
   end
 
   def test_argument
-    assert_nothing_raised do
+    template = Liquid::Template.parse(' {{ errors.argument_error }} ')
+    assert_equal(' Liquid error: argument error ', template.render('errors' => ErrorDrop.new))
 
-      template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
+    assert_equal(1, template.errors.size)
-      assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
+    assert_equal(ArgumentError, template.errors.first.class)
-
-      assert_equal 1, template.errors.size
-      assert_equal ArgumentError, template.errors.first.class
-    end
   end
 
   def test_missing_endtag_parse_time_error
-    assert_raise(Liquid::SyntaxError) do
+    assert_raises(Liquid::SyntaxError) do
       Liquid::Template.parse(' {% for a in b %} ... ')
     end
   end
 
   def test_unrecognized_operator
     with_error_mode(:strict) do
-      assert_raise(SyntaxError) do
+      assert_raises(SyntaxError) do
         Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
       end
     end
   end
-  
+
   def test_lax_unrecognized_operator
-    assert_nothing_raised do
+    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 ' Liquid error: Unknown operator =! ', template.render
+    assert_equal(1, template.errors.size)
-      assert_equal 1, template.errors.size
+    assert_equal(Liquid::ArgumentError, template.errors.first.class)
-      assert_equal Liquid::ArgumentError, template.errors.first.class
+  end
+
+  def test_with_line_numbers_adds_numbers_to_parser_errors
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar
+
+          {% "cat" | foobar %}
+
+          bla
+        ',
+        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)
+  end
+
+  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
+    template = Liquid::Template.parse('
+        foobar
+
+        {% if 1 =! 2 %}ok{% endif %}
+
+        bla
+            ',
+      error_mode: :warn,
+      line_numbers: true)
+
+    assert_equal(['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
+      template.warnings.map(&:message))
+  end
+
+  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar
+
+          {% if 1 =! 2 %}ok{% endif %}
+
+          bla
+                ',
+        error_mode: :strict,
+        line_numbers: true)
+    end
+
+    assert_equal('Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message)
+  end
+
+  def test_syntax_errors_in_nested_blocks_have_correct_line_number
+    err = assert_raises(SyntaxError) do
+      Liquid::Template.parse('
+          foobar
+
+          {% if 1 != 2 %}
+            {% foo %}
+          {% endif %}
+
+          bla
+                ',
+        line_numbers: true)
+    end
+
+    assert_equal("Liquid syntax error (line 5): Unknown tag 'foo'", err.message)
   end
 
   def test_strict_error_messages
-    err = assert_raise(SyntaxError) do
+    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 'Unexpected character = in "1 =! 2"', err.message
+    assert_equal('Liquid syntax error: Unexpected character = in "1 =! 2"', err.message)
 
-    err = assert_raise(SyntaxError) do
+    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}', :error_mode => :strict)
+      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
     end
-    assert_equal 'Unexpected character % in "{{%%%}}"', err.message
+    assert_equal('Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message)
   end
 
   def test_warnings
-    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', :error_mode => :warn)
+    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
-    assert_equal 3, template.warnings.size
+    assert_equal(3, template.warnings.size)
-    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].message
+    assert_equal('Unexpected character ~ in "~~~"', template.warnings[0].to_s(false))
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].message
+    assert_equal('Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false))
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
+    assert_equal('Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false))
-    assert_equal '', template.render
+    assert_equal('', template.render)
+  end
+
+  def test_warning_line_numbers
+    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
+    assert_equal('Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message)
+    assert_equal('Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message)
+    assert_equal('Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message)
+    assert_equal(3, template.warnings.size)
+    assert_equal([1, 2, 3], template.warnings.map(&:line_number))
   end
 
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
   def test_exceptions_propagate
-    assert_raise Exception do
+    assert_raises Exception do
-      template = Liquid::Template.parse( ' {{ errors.exception }} '  )
+      template = Liquid::Template.parse('{{ errors.exception }}')
       template.render('errors' => ErrorDrop.new)
     end
   end
-end # ErrorHandlingTest
+
+  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

test/integration/filter_test.rb

@@ -1,30 +1,38 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module MoneyFilter
   def money(input)
-    sprintf(' %d$ ', input)
+    format(' %d$ ', input)
   end
 
   def money_with_underscore(input)
-    sprintf(' %d$ ', input)
+    format(' %d$ ', input)
   end
 end
 
 module CanadianMoneyFilter
   def money(input)
-    sprintf(' %d$ CAD ', input)
+    format(' %d$ CAD ', input)
   end
 end
 
 module SubstituteFilter
-  def substitute(input, params={})
+  def substitute(input, params = {})
-    input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
+    input.gsub(/%\{(\w+)\}/) { |_match| params[Regexp.last_match(1)] }
   end
 end
 
-class FiltersTest < Test::Unit::TestCase
+class FiltersTest < Minitest::Test
   include Liquid
 
+  module OverrideObjectMethodFilter
+    def tap(_input)
+      "tap overridden"
+    end
+  end
+
   def setup
     @context = Context.new
   end
@@ -33,13 +41,13 @@ class FiltersTest < Test::Unit::TestCase
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
 
-    assert_equal ' 1000$ ', Variable.new("var | money").render(@context)
+    assert_equal(' 1000$ ', Template.parse("{{var | money}}").render(@context))
   end
 
   def test_underscore_in_filter_name
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Variable.new("var | money_with_underscore").render(@context)
+    assert_equal(' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context))
   end
 
   def test_second_filter_overwrites_first
@@ -47,79 +55,126 @@ class FiltersTest < Test::Unit::TestCase
     @context.add_filters(MoneyFilter)
     @context.add_filters(CanadianMoneyFilter)
 
-    assert_equal ' 1000$ CAD ', Variable.new("var | money").render(@context)
+    assert_equal(' 1000$ CAD ', Template.parse("{{var | money}}").render(@context))
   end
 
   def test_size
     @context['var'] = 'abcd'
     @context.add_filters(MoneyFilter)
 
-    assert_equal 4, Variable.new("var | size").render(@context)
+    assert_equal('4', Template.parse("{{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", Variable.new("var | join").render(@context)
+    assert_equal("1 2 3 4", Template.parse("{{var | join}}").render(@context))
   end
 
   def test_sort
     @context['value'] = 3
-    @context['numbers'] = [2,1,4,3]
+    @context['numbers'] = [2, 1, 4, 3]
     @context['words'] = ['expected', 'as', 'alphabetic']
-    @context['arrays'] = [['flattened'], ['are']]
+    @context['arrays'] = ['flower', 'are']
+    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
 
-    assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
+    assert_equal('1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context))
-    assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
+    assert_equal('alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context))
-    assert_equal [3], Variable.new("value | sort").render(@context)
+    assert_equal('3', Template.parse("{{value | sort}}").render(@context))
-    assert_equal ['are', 'flattened'], Variable.new("arrays | 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))
   end
 
   def test_strip_html
     @context['var'] = "<b>bla blub</a>"
 
-    assert_equal "bla blub", Variable.new("var | strip_html").render(@context)
+    assert_equal("bla blub", Template.parse("{{ var | strip_html }}").render(@context))
   end
 
   def test_strip_html_ignore_comments_with_html
     @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
 
-    assert_equal "bla blub", Variable.new("var | strip_html").render(@context)
+    assert_equal("bla blub", Template.parse("{{ var | strip_html }}").render(@context))
   end
 
   def test_capitalize
     @context['var'] = "blub"
 
-    assert_equal "Blub", Variable.new("var | capitalize").render(@context)
+    assert_equal("Blub", Template.parse("{{ var | capitalize }}").render(@context))
   end
 
   def test_nonexistent_filter_is_ignored
     @context['var'] = 1000
 
-    assert_equal 1000, Variable.new("var | xyzzy").render(@context)
+    assert_equal('1000', Template.parse("{{ var | xyzzy }}").render(@context))
   end
 
   def test_filter_with_keyword_arguments
     @context['surname'] = 'john'
+    @context['input'] = 'hello %{first_name}, %{last_name}'
     @context.add_filters(SubstituteFilter)
-    output = Variable.new(%! 'hello %{first_name}, %{last_name}' | substitute: first_name: surname, last_name: 'doe' !).render(@context)
+    output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
-    assert_equal 'hello john, doe', output
+    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 < Test::Unit::TestCase
+class FiltersInTemplate < Minitest::Test
   include Liquid
 
   def test_local_global
-    Template.register_filter(MoneyFilter)
+    with_global_filter(MoneyFilter) do
-
+      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
-    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
 
   def test_local_filter_with_deprecated_syntax
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
+    assert_equal(" 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter))
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
+    assert_equal(" 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter]))
   end
 end # FiltersTest
+
+class TestObject < Liquid::Drop
+  attr_accessor :a
+  def initialize(a)
+    @a = a
+  end
+end

test/integration/hash_ordering_test.rb

@@ -1,25 +1,25 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-module MoneyFilter
+class HashOrderingTest < Minitest::Test
-  def money(input)
+  module MoneyFilter
-    sprintf(' %d$ ', input)
+    def money(input)
+      format(' %d$ ', input)
+    end
   end
-end
 
-module CanadianMoneyFilter
+  module CanadianMoneyFilter
-  def money(input)
+    def money(input)
-    sprintf(' %d$ CAD ', input)
+      format(' %d$ CAD ', input)
+    end
   end
-end
 
-class HashOrderingTest < Test::Unit::TestCase
   include Liquid
 
- def test_global_register_order
+  def test_global_register_order
-    Template.register_filter(MoneyFilter)
+    with_global_filter(MoneyFilter, CanadianMoneyFilter) do
-    Template.register_filter(CanadianMoneyFilter)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
-
+    end
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
+  end
- end
-
 end

test/integration/output_test.rb

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 module FunnyFilter
-  def make_funny(input)
+  def make_funny(_input)
     'LOL'
   end
 
@@ -14,7 +16,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,95 +24,102 @@ module FunnyFilter
   end
 
   def link_to(name, url)
-    %|<a href="#{url}">#{name}</a>|
+    %(<a href="#{url}">#{name}</a>)
   end
-
 end
 
-class OutputTest < Test::Unit::TestCase
+class OutputTest < Minitest::Test
   include Liquid
 
   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)
+    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)
+    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'}} !
+    text = %( {{ car.gm | add_tag : 'span', 'bar'}} )
-    expected = %| <span id="bar">bad</span> |
+    expected = %( <span id="bar">bad</span> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_variable_args
-    text = %! {{ car.gm | add_tag : 'span', car.bmw}} !
+    text = %( {{ car.gm | add_tag : 'span', car.bmw}} )
-    expected = %| <span id="good">bad</span> |
+    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

test/integration/parse_tree_visitor_test.rb

@@ -0,0 +1,247 @@
+# 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