Use StringSlice.join on the rendered results.

Add a StringSlice class to use in the nodelist.
Add convenience methods for getting a struct from a ruby object.
2026-01-02 16:25:42 +03:00 · 2014-02-28 14:12:57 -05:00 · 2014-02-28 13:16:07 -05:00 · 2014-02-28 10:08:55 -05:00 · 2014-02-28 07:47:36 -05:00 · 2014-02-27 23:16:11 -05:00
177 changed files with 5412 additions and 10769 deletions
--- a/.github/probots.yml
+++ b/.github/probots.yml
@@ -1,2 +0,0 @@
 enabled:
  - cla
--- a/.gitignore
+++ b/.gitignore
@@ -5,6 +5,6 @@ pkg
 *.rbc
 .rvmrc
 .ruby-version
 *.bundle
 /tmp
 Gemfile.lock
 .bundle
 .byebug_history
--- a/.rubocop-https---shopify-github-io-ruby-style-guide-rubocop-yml
+++ b/.rubocop-https---shopify-github-io-ruby-style-guide-rubocop-yml
--- a/.rubocop.yml
+++ b/.rubocop.yml
@@ -1,16 +0,0 @@
 inherit_from:
  - https://shopify.github.io/ruby-style-guide/rubocop.yml
  - .rubocop_todo.yml
 require: rubocop-performance
 Performance:
  Enabled: true
 AllCops:
  Exclude:
    - 'vendor/bundle/**/*'
 Naming/MethodName:
  Exclude:
    - 'example/server/liquid_servlet.rb'
--- a/.rubocop_todo.yml
+++ b/.rubocop_todo.yml
@@ -1,94 +0,0 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
 # on 2019-09-11 06:34:25 +1000 using RuboCop version 0.74.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 # Offense count: 2
 Lint/AmbiguousOperator:
  Exclude:
    - 'test/unit/condition_unit_test.rb'
 # Offense count: 21
 # Configuration parameters: AllowSafeAssignment.
 Lint/AssignmentInCondition:
  Exclude:
    - 'lib/liquid/block_body.rb'
    - 'lib/liquid/lexer.rb'
    - 'lib/liquid/standardfilters.rb'
    - 'lib/liquid/tags/for.rb'
    - 'lib/liquid/tags/if.rb'
    - 'lib/liquid/tags/raw.rb'
    - 'lib/liquid/variable.rb'
    - 'performance/profile.rb'
    - 'test/test_helper.rb'
    - 'test/unit/tokenizer_unit_test.rb'
 # Offense count: 2
 # Cop supports --auto-correct.
 # Configuration parameters: EnforcedStyle.
 # SupportedStyles: runtime_error, standard_error
 Lint/InheritException:
  Exclude:
    - 'lib/liquid/interrupts.rb'
 # Offense count: 2
 Lint/UselessAssignment:
  Exclude:
    - 'performance/shopify/database.rb'
 # Offense count: 1
 # Configuration parameters: CheckForMethodsWithNoSideEffects.
 Lint/Void:
  Exclude:
    - 'lib/liquid/parse_context.rb'
 # Offense count: 98
 # Cop supports --auto-correct.
 # Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
 Metrics/LineLength:
  Max: 294
 # Offense count: 44
 Naming/ConstantName:
  Exclude:
    - 'lib/liquid.rb'
    - 'lib/liquid/block_body.rb'
    - 'lib/liquid/tags/assign.rb'
    - 'lib/liquid/tags/capture.rb'
    - 'lib/liquid/tags/case.rb'
    - 'lib/liquid/tags/cycle.rb'
    - 'lib/liquid/tags/for.rb'
    - 'lib/liquid/tags/if.rb'
    - 'lib/liquid/tags/include.rb'
    - 'lib/liquid/tags/raw.rb'
    - 'lib/liquid/tags/table_row.rb'
    - 'lib/liquid/variable.rb'
    - 'performance/shopify/comment_form.rb'
    - 'performance/shopify/paginate.rb'
    - 'test/integration/tags/include_tag_test.rb'
 # Offense count: 5
 Style/ClassVars:
  Exclude:
    - 'lib/liquid/condition.rb'
    - 'lib/liquid/strainer.rb'
    - 'lib/liquid/template.rb'
 # Offense count: 1
 # Configuration parameters: AllowCoercion.
 Style/DateTime:
  Exclude:
    - 'test/unit/context_unit_test.rb'
 # Offense count: 9
 # Cop supports --auto-correct.
 # Configuration parameters: AllowAsExpressionSeparator.
 Style/Semicolon:
  Exclude:
    - 'test/integration/error_handling_test.rb'
    - 'test/integration/template_test.rb'
    - 'test/unit/context_unit_test.rb'
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,30 +1,16 @@
 language: ruby
 cache: bundler
 rvm:
-  - 2.4
+  - 1.9.3
-  - 2.5
+  - 2.0.0
-  - &latest_ruby 2.6
+  - 2.1.0
-  - 2.7
+  - jruby-19mode
  - ruby-head
  - jruby-head
-  - truffleruby
+  - rbx-19mode
 matrix:
  include:
    - rvm: *latest_ruby
      script: bundle exec rake memory_profile:run
      name: Profiling Memory Usage
  allow_failures:
-    - rvm: ruby-head
+    - rvm: rbx-19mode
    - rvm: jruby-head
    - rvm: truffleruby
-branches:
+script: "rake test"
  only:
    - master
    - gh-pages
    - /.*-stable/
 notifications:
  disable: true
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,22 +4,23 @@
 * Bugfixes
 * Performance improvements
-* Features that are likely to be useful to the majority of Liquid users
+* Features which are likely to be useful to the majority of Liquid users
 ## Things we won't merge
-* Code that introduces considerable performance degrations
+* Code which introduces considerable performance degrations
-* Code that touches performance-critical parts of Liquid and comes without benchmarks
+* Code which touches performance critical parts of Liquid and comes without benchmarks
-* Features that are not important for most people (we want to keep the core Liquid code small and tidy)
+* Features which are not important for most people (we want to keep the core Liquid code small and tidy)
-* Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
+* Features which can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
-* Code that does not include tests
+* Code which comes without tests
-* Code that breaks existing tests
+* Code which breaks existing tests
 ## Workflow
 * Fork the Liquid repository
 * Create a new branch in your fork
-* If it makes sense, add tests for your code and/or run a performance benchmark
+* If it makes sense, add tests for your code and run a performance benchmark
-* Make sure all tests pass (`bundle exec rake`)
+* Make sure all tests pass
 * Create a pull request
 * In the description, ping one of [@boourns](https://github.com/boourns), [@fw42](https://github.com/fw42), [@camilo](https://github.com/camilo), [@dylanahsmith](https://github.com/dylanahsmith), or [@arthurnn](https://github.com/arthurnn) and ask for a code review.
--- a/24
+++ b/24
@@ -1,27 +1,3 @@
 # frozen_string_literal: true
 source 'https://rubygems.org'
 git_source(:github) do |repo_name|
  "https://github.com/#{repo_name}.git"
 end
 gemspec
 group :benchmark, :test do
  gem 'benchmark-ips'
  gem 'memory_profiler'
  gem 'terminal-table'
  install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
    gem 'stackprof'
  end
 end
 group :test do
  gem 'rubocop', '~> 0.74.0', require: false
  gem 'rubocop-performance', require: false
  platform :mri, :truffleruby do
    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
  end
 end
--- a/History.md
+++ b/History.md
@@ -1,208 +1,59 @@
-# Liquid Change Log
+# Liquid Version History
-## 4.0.3 / 2019-03-12
+## 3.0.0 / not yet released / branch "master"
-### Fixed
+* ...
-* Fix break and continue tags inside included templates in loops (#1072) [Justin Li]
+* 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]
 * Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
-## 4.0.2 / 2019-03-08
+## 2.6.0 / 2013-11-25 / branch "2.6-stable"
 ### 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]
+* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
-* Bugfix for #114: strip_html filter supports style tags [James Allardice]
+* Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]
-* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup]
+* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup, ndwebgroup]
-* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten]
+* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten, fw42]
-* Bugfix for #204: 'raw' parsing bug [Florian Weingarten]
+* Bugfix for #204: 'raw' parsing bug [Florian Weingarten, fw42]
-* Bugfix for #150: 'for' parsing bug [Peter Schröder]
+* Bugfix for #150: 'for' parsing bug [Peter Schröder, phoet]
-* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder]
+* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder, phoet]
-* Bugfix for #174, "can't convert Fixnum into String" for "replace" [jsw0528]
+* Bugfix for #174, "can't convert Fixnum into String" for "replace" [wǒ_is神仙, jsw0528]
-* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep]
+* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep, darkhelmet]
-* Resource limits [Florian Weingarten]
+* Resource limits [Florian Weingarten, fw42]
-* Add reverse filter [Jay Strybis]
+* Add reverse filter [Jay Strybis, unreal]
 * Add utf-8 support
-* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos]
+* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos, astathopoulos]
-* Cache tokenized partial templates [Tom Burns]
+* Cache tokenized partial templates [Tom Burns, boourns]
-* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer]
+* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer, stomar]
-* Better documentation for 'include' tag (closes #163) [Peter Schröder]
+* Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
-* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves]
+* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]
-## 2.5.5 / 2014-01-10 / branch "2-5-stable"
+## 2.5.4 / 2013-11-11 / branch "2.5-stable"
-Security fix, cherry-picked from master (4e14a65):
+* Fix "can't convert Fixnum into String" for "replace", see #173, [wǒ_is神仙, jsw0528]
 * 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]
+* #232, #234, #237: Fix map filter bugs [Florian Weingarten, fw42]
 ## 2.5.2 / 2013-09-03 / deleted
@@ -210,7 +61,7 @@ Yanked from rubygems, as it contained too many changes that broke compatibility.
 ## 2.5.1 / 2013-07-24
-* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten]
+* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten, fw42]
 ## 2.5.0 / 2013-03-06
--- a/0
+++ b/0
--- a/README.md
+++ b/README.md
@@ -1,6 +1,4 @@
-[![Build Status](https://api.travis-ci.org/Shopify/liquid.svg?branch=master)](http://travis-ci.org/Shopify/liquid)
+[![Build Status](https://secure.travis-ci.org/Shopify/liquid.png?branch=master)](http://travis-ci.org/Shopify/liquid)
 [![Inline docs](http://inch-ci.org/github/Shopify/liquid.svg?branch=master)](http://inch-ci.org/github/Shopify/liquid)
 # Liquid template engine
 * [Contributing guidelines](CONTRIBUTING.md)
@@ -42,8 +40,6 @@ Liquid is a template engine which was written with very specific requirements:
 ## How to use Liquid
 Install Liquid by adding `gem 'liquid'` to your gemfile.
 Liquid supports a very simple API based around the Liquid::Template class.
 For standard use you can just pass it the content of a file and call render with a parameters hash.
@@ -75,40 +71,3 @@ This is useful for doing things like enabling strict mode only in the theme edit
 It is recommended that you enable `:strict` or `:warn` mode on new apps to stop invalid templates from being created.
 It is also recommended that you use it in the template editors of existing apps to give editors better error messages.
 ### Undefined variables and filters
 By default, the renderer doesn't raise or in any other way notify you if some variables or filters are missing, i.e. not passed to the `render` method.
 You can improve this situation by passing `strict_variables: true` and/or `strict_filters: true` options to the `render` method.
 When one of these options is set to true, all errors about undefined variables and undefined filters will be stored in `errors` array of a `Liquid::Template` instance.
 Here are some examples:
 ```ruby
 template = Liquid::Template.parse("{{x}} {{y}} {{z.a}} {{z.b}}")
 template.render({ 'x' => 1, 'z' => { 'a' => 2 } }, { strict_variables: true })
 #=> '1  2 ' # when a variable is undefined, it's rendered as nil
 template.errors
 #=> [#<Liquid::UndefinedVariable: Liquid error: undefined variable y>, #<Liquid::UndefinedVariable: Liquid error: undefined variable b>]
 ```
 ```ruby
 template = Liquid::Template.parse("{{x | filter1 | upcase}}")
 template.render({ 'x' => 'foo' }, { strict_filters: true })
 #=> '' # when at least one filter in the filter chain is undefined, a whole expression is rendered as nil
 template.errors
 #=> [#<Liquid::UndefinedFilter: Liquid error: undefined filter filter1>]
 ```
 If you want to raise on a first exception instead of pushing all of them in `errors`, you can use `render!` method:
 ```ruby
 template = Liquid::Template.parse("{{x}} {{y}}")
 template.render!({ 'x' => 1}, { strict_variables: true })
 #=> Liquid::UndefinedVariable: Liquid error: undefined variable y
 ```
 ### Usage tracking
 To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
 Once you have enabled usage tracking, we recommend reporting any events through Github Issues that your system may be logging. It is highly likely this event has been added to consider deprecating or improving code specific to this event, so please raise any concerns.
--- a/69
+++ b/69
@@ -1,64 +1,43 @@
 # frozen_string_literal: true
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+require 'rake/extensiontask'
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"
-task(default: [:test, :rubocop])
+task :default => 'test'
-desc('run test suite with default parser')
+desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
  t.libs << '.' << 'lib' << 'test'
-  t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
+  t.test_files = FileList['test/liquid/**/*_test.rb']
  t.verbose = false
 end
-desc('run test suite with warn error mode')
+desc 'run test suite with warn error mode'
 task :warn_test do
  ENV['LIQUID_PARSER_MODE'] = 'warn'
  Rake::Task['base_test'].invoke
 end
-task :rubocop do
+desc 'runs test suite with both strict and lax parsers'
  if RUBY_ENGINE == 'ruby'
    require 'rubocop/rake_task'
    RuboCop::RakeTask.new
  end
 end
 desc('runs test suite with both strict and lax parsers')
 task :test do
  ENV['LIQUID_PARSER_MODE'] = 'lax'
  Rake::Task['base_test'].invoke
  ENV['LIQUID_PARSER_MODE'] = 'strict'
  Rake::Task['base_test'].reenable
  Rake::Task['base_test'].invoke
  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
    ENV['LIQUID_C'] = '1'
    ENV['LIQUID_PARSER_MODE'] = 'lax'
    Rake::Task['base_test'].reenable
    Rake::Task['base_test'].invoke
    ENV['LIQUID_PARSER_MODE'] = 'strict'
    Rake::Task['base_test'].reenable
    Rake::Task['base_test'].invoke
  end
 end
-task(gem: :build)
+task :gem => :build
 task :build do
  system "gem build liquid.gemspec"
 end
-task install: :build do
+task :install => :build do
  system "gem install liquid-#{Liquid::VERSION}.gem"
 end
-task release: :build do
+task :release => :build do
  system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'"
  system "git push --tags"
  system "gem push liquid-#{Liquid::VERSION}.gem"
@@ -66,6 +45,7 @@ task release: :build do
 end
 namespace :benchmark do
  desc "Run the liquid benchmark with lax parsing"
  task :run do
    ruby "./performance/benchmark.rb lax"
@@ -77,30 +57,31 @@ namespace :benchmark do
  end
 end
 namespace :profile do
  desc "Run the liquid profile/performance coverage"
  task :run do
    ruby "./performance/profile.rb"
  end
-  desc "Run the liquid profile/performance coverage with strict parsing"
+  task :stackprof do
-  task :strict do
+    ruby "./performance/stackprof.rb"
    ruby "./performance/profile.rb strict"
  end
  desc "Run KCacheGrind"
  task :grind => :run  do
    system "qcachegrind /tmp/liquid.rubyprof_calltreeprinter.txt"
  end
 end
-namespace :memory_profile do
+desc "Run example"
  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
+Rake::ExtensionTask.new "liquid" do |ext|
-  exec 'irb -I lib -r liquid'
+  ext.lib_dir = "lib/liquid"
 end
 Rake::Task[:test].prerequisites << :compile
--- a/example/server/example_servlet.rb
+++ b/example/server/example_servlet.rb
@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 module ProductsFilter
  def price(integer)
-    format("$%.2d USD", integer / 100.0)
+    sprintf("$%.2d USD", integer / 100.0)
  end
  def prettyprint(text)
-    text.gsub(/\*(.*)\*/, '<b>\1</b>')
+    text.gsub( /\*(.*)\*/, '<b>\1</b>' )
  end
  def count(array)
@@ -19,28 +17,25 @@ module ProductsFilter
 end
 class Servlet < LiquidServlet
  def index
    { 'date' => Time.now }
  end
  def products
-    { 'products' => products_list, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true }
+    { 'products' => products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true}
  end
  private
  def products_list
-    [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+    [{'name' => 'Arbor 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
--- a/example/server/liquid_servlet.rb
+++ b/example/server/liquid_servlet.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
  def do_GET(req, res)
    handle(:get, req, res)
  end
@@ -11,20 +10,19 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
  private
-  def handle(_type, req, res)
+  def handle(type, req, res)
-    @request = req
+    @request, @response = req, res
    @response = res
    @request.path_info =~ /(\w+)\z/
-    @action = Regexp.last_match(1) || 'index'
+    @action = $1 || 'index'
    @assigns = send(@action) if respond_to?(@action)
    @response['Content-Type'] = "text/html"
    @response.status = 200
-    @response.body = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
+    @response.body = Liquid::Template.parse(read_template).render(@assigns, :filters => [ProductsFilter])
  end
  def read_template(filename = @action)
-    File.read("#{__dir__}/templates/#{filename}.liquid")
+    File.read( File.dirname(__FILE__) + "/templates/#{filename}.liquid" )
  end
 end
--- a/example/server/server.rb
+++ b/example/server/server.rb
@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 require 'webrick'
 require 'rexml/document'
-require_relative '../../lib/liquid'
+DIR = File.expand_path(File.dirname(__FILE__))
-require_relative 'liquid_servlet'
+
-require_relative 'example_servlet'
+require DIR + '/../../lib/liquid'
 require DIR + '/liquid_servlet'
 require DIR + '/example_servlet'
 # Setup webrick
-server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
+server = WEBrick::HTTPServer.new( :Port => ARGV[1] || 3000 )
 server.mount('/', Servlet)
-trap("INT") { server.shutdown }
+trap("INT"){ server.shutdown }
 server.start
--- a/example/server/templates/index.liquid
+++ b/example/server/templates/index.liquid
@@ -3,4 +3,4 @@
 <p>It is {{date}}</p>
-<p>Check out the <a href="/products">Products</a> screen </p>
+<p>Check out the <a href="http://localhost:3000/products">Products</a> screen </p>
--- a/example/server/templates/products.liquid
+++ b/example/server/templates/products.liquid
@@ -16,12 +16,12 @@
  </head>
  <body>
-    {% assign all_products = products | concat: more_products  %}
+
    <h1>{{ description | split: '~' | first }}</h1>
    <h2>{{ description | split: '~' | last }}</h2>
-    <h2>There are currently {{all_products | count}} products in the {{section}} catalog</h2>
+    <h2>There are currently {{products | count}} products in the {{section}} catalog</h2>
    {% if cool_products %}
      Cool products :)
@@ -31,7 +31,7 @@
    <ul id="products">
-      {% for product in all_products %}
+      {% for product in products %}
        <li>
          <h2>{{product.name}}</h2>
          Only {{product.price | price }}
--- a/ext/liquid/block.c
+++ b/ext/liquid/block.c
@@ -0,0 +1,167 @@
 #include "liquid_ext.h"
 VALUE cLiquidBlock;
 ID intern_assert_missing_delimitation, intern_block_delimiter, intern_is_blank,
   intern_new_with_options, intern_tags, intern_unknown_tag, intern_unterminated_tag,
   intern_unterminated_variable;
 struct liquid_tag
 {
    char *name, *markup;
    long name_length, markup_length;
 };
 static bool parse_tag(struct liquid_tag *tag, char *token, long token_length)
 {
    // Strip {{ and }} braces
    token += 2;
    token_length -= 4;
    char *end = token + token_length;
    while (token < end && isspace(*token))
        token++;
    tag->name = token;
    char c = *token;
    while (token < end && (isalnum(c) || c == '_'))
        c = *(++token);
    tag->name_length = token - tag->name;
    if (!tag->name_length) {
        memset(tag, 0, sizeof(*tag));
        return false;
    }
    while (token < end && isspace(*token))
        token++;
    tag->markup = token;
    char *last = end - 1;
    while (token < last && isspace(*last))
        last--;
    end = last + 1;
    tag->markup_length = end - token;
    return true;
 }
 static VALUE rb_parse_body(VALUE self, VALUE tokenizerObj)
 {
    struct liquid_tokenizer *tokenizer = LIQUID_TOKENIZER_GET_STRUCT(tokenizerObj);
    bool blank = true;
    VALUE nodelist = rb_iv_get(self, "@nodelist");
    if (nodelist == Qnil) {
        nodelist = rb_ary_new();
        rb_iv_set(self, "@nodelist", nodelist);
    } else {
        rb_ary_clear(nodelist);
    }
    struct token token;
    while (true) {
        liquid_tokenizer_next(tokenizer, &token);
        switch (token.type) {
        case TOKEN_NONE:
            /*
             * 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
             */
            rb_funcall(self, intern_assert_missing_delimitation, 0);
            goto done;
        case TOKEN_INVALID:
        {
            VALUE token_obj = rb_str_new(token.str, token.length);
            if (token.str[1] == '%')
                rb_funcall(self, intern_unterminated_tag, 1, token_obj);
            else
                rb_funcall(self, intern_unterminated_variable, 1, token_obj);
            break;
        }
        case TOKEN_TAG:
        {
            struct liquid_tag tag;
            if (!parse_tag(&tag, token.str, token.length)) {
                // FIXME: provide more appropriate error message
                rb_funcall(self, intern_unterminated_tag, 1, rb_str_new(token.str, token.length));
            } else {
                if (tag.name_length >= 3 && !memcmp(tag.name, "end", 3)) {
                    VALUE block_delimiter = rb_funcall(self, intern_block_delimiter, 0);
                    if (TYPE(block_delimiter) == T_STRING &&
                        tag.name_length == RSTRING_LEN(block_delimiter) &&
                        !memcmp(tag.name, RSTRING_PTR(block_delimiter), tag.name_length))
                    {
                        goto done;
                    }
                }
                VALUE tags = rb_funcall(cLiquidTemplate, intern_tags, 0);
                Check_Type(tags, T_HASH);
                VALUE tag_name = rb_str_new(tag.name, tag.name_length);
                VALUE tag_class = rb_hash_lookup(tags, tag_name);
                VALUE markup = rb_str_new(tag.markup, tag.markup_length);
                if (tag_class != Qnil) {
                    VALUE options = rb_iv_get(self, "@options");
                    if (options == Qnil)
                        options = rb_hash_new();
                    VALUE new_tag = rb_funcall(tag_class, intern_new_with_options, 4,
                                               tag_name, markup, tokenizerObj, options);
                    if (blank) {
                        VALUE blank_block = rb_funcall(new_tag, intern_is_blank, 0);
                        if (blank_block == Qnil || blank_block == Qfalse)
                            blank = false;
                    }
                    rb_ary_push(nodelist, new_tag);
                } else {
                    rb_funcall(self, intern_unknown_tag, 3, tag_name, markup, tokenizerObj);
                    /*
                     * multi-block tags may store the nodelist in a block array on unknown_tag
                     * then replace @nodelist with a new array. We need to use the new array
                     * for the block following the tag token.
                     */
                    nodelist = rb_iv_get(self, "@nodelist");
                }
            }
            break;
        }
        case TOKEN_VARIABLE:
        {
            VALUE markup = rb_str_new(token.str + 2, token.length - 4);
            VALUE options = rb_iv_get(self, "@options");
            VALUE new_var = rb_funcall(cLiquidVariable, intern_new, 2, markup, options);
            rb_ary_push(nodelist, new_var);
            blank = false;
            break;
        }
        case TOKEN_STRING:
            rb_ary_push(nodelist, liquid_string_slice_new(token.str, token.length));
            if (blank) {
                int i;
                for (i = 0; i < token.length; i++) {
                    if (!isspace(token.str[i])) {
                        blank = false;
                        break;
                    }
                }
            }
            break;
        }
    }
 done:
    rb_iv_set(self, "@blank", blank ? Qtrue : Qfalse);
    return Qnil;
 }
 void init_liquid_block()
 {
    intern_assert_missing_delimitation = rb_intern("assert_missing_delimitation!");
    intern_block_delimiter = rb_intern("block_delimiter");
    intern_is_blank = rb_intern("blank?");
    intern_new_with_options = rb_intern("new_with_options");
    intern_tags = rb_intern("tags");
    intern_unknown_tag = rb_intern("unknown_tag");
    intern_unterminated_tag = rb_intern("unterminated_tag");
    intern_unterminated_variable = rb_intern("unterminated_variable");
    cLiquidBlock = rb_define_class_under(mLiquid, "Block", cLiquidTag);
    rb_define_method(cLiquidBlock, "parse_body", rb_parse_body, 1);
 }
--- a/ext/liquid/block.h
+++ b/ext/liquid/block.h
@@ -0,0 +1,8 @@
 #ifndef LIQUID_BLOCK_H
 #define LIQUID_BLOCK_H
 void init_liquid_block();
 extern VALUE cLiquidBlock;
 #endif
--- a/ext/liquid/extconf.rb
+++ b/ext/liquid/extconf.rb
@@ -0,0 +1,3 @@
 require 'mkmf'
 $CFLAGS << ' -Wall'
 create_makefile("liquid/liquid")
--- a/ext/liquid/liquid_ext.c
+++ b/ext/liquid/liquid_ext.c
@@ -0,0 +1,18 @@
 #include "liquid_ext.h"
 VALUE mLiquid;
 VALUE cLiquidTemplate, cLiquidTag, cLiquidVariable;
 ID intern_new;
 void Init_liquid(void)
 {
    intern_new = rb_intern("new");
    mLiquid = rb_define_module("Liquid");
    cLiquidTemplate = rb_define_class_under(mLiquid, "Template", rb_cObject);
    cLiquidTag = rb_define_class_under(mLiquid, "Tag", rb_cObject);
    cLiquidVariable = rb_define_class_under(mLiquid, "Variable", rb_cObject);
    init_liquid_tokenizer();
    init_liquid_block();
    init_liquid_string_slice();
 }
--- a/ext/liquid/liquid_ext.h
+++ b/ext/liquid/liquid_ext.h
@@ -0,0 +1,17 @@
 #ifndef LIQUID_EXT_H
 #define LIQUID_EXT_H
 #include <stdbool.h>
 #include <ctype.h>
 #include <ruby.h>
 #include "tokenizer.h"
 #include "block.h"
 #include "slice.h"
 #include "utils.h"
 extern ID intern_new;
 extern VALUE mLiquid;
 extern VALUE cLiquidTemplate, cLiquidTag, cLiquidVariable;
 #endif
--- a/ext/liquid/slice.c
+++ b/ext/liquid/slice.c
@@ -0,0 +1,167 @@
 #include "liquid_ext.h"
 VALUE cLiquidStringSlice;
 static void mark_slice(void *ptr)
 {
    if (!ptr)
        return;
    struct string_slice *slice = ptr;
    rb_gc_mark(slice->source);
 }
 static void free_slice(void *ptr)
 {
    struct string_slice *slice = ptr;
    xfree(slice);
 }
 VALUE liquid_string_slice_new(const char *str, long length)
 {
    return rb_funcall(cLiquidStringSlice, intern_new, 3, rb_str_new(str, length), INT2FIX(0), INT2FIX(length));
 }
 static VALUE rb_allocate(VALUE klass)
 {
    struct string_slice *slice;
    VALUE obj = Data_Make_Struct(klass, struct string_slice, mark_slice, free_slice, slice);
    return obj;
 }
 static VALUE rb_initialize(VALUE self, VALUE source, VALUE offset_value, VALUE length_value)
 {
    long offset = rb_fix2int(offset_value);
    long length = rb_fix2int(length_value);
    if (length < 0)
        rb_raise(rb_eArgError, "negative string length");
    if (offset < 0)
        rb_raise(rb_eArgError, "negative string offset");
    if (TYPE(source) == T_DATA && RBASIC_CLASS(source) == cLiquidStringSlice) {
        struct string_slice *source_slice = DATA_PTR(source);
        source = source_slice->source;
        offset += source_slice->str - RSTRING_PTR(source);
    } else {
        source = rb_string_value(&source);
        source = rb_str_dup_frozen(source);
    }
    struct string_slice *slice;
    Data_Get_Struct(self, struct string_slice, slice);
    slice->source = source;
    slice->str = RSTRING_PTR(source) + offset;
    slice->length = length;
    if (length > RSTRING_LEN(source) - offset)
        rb_raise(rb_eArgError, "slice bounds outside source string bounds");
    return Qnil;
 }
 static VALUE rb_slice_to_str(VALUE self)
 {
    struct string_slice *slice;
    Data_Get_Struct(self, struct string_slice, slice);
    VALUE source = slice->source;
    if (slice->str == RSTRING_PTR(source) && slice->length == RSTRING_LEN(source))
        return source;
    source = rb_str_new(slice->str, slice->length);
    slice->source = source;
    slice->str = RSTRING_PTR(source);
    return source;
 }
 static VALUE rb_slice_slice(VALUE self, VALUE offset, VALUE length)
 {
    return rb_funcall(cLiquidStringSlice, intern_new, 3, self, offset, length);
 }
 static VALUE rb_slice_length(VALUE self)
 {
    struct string_slice *slice;
    Data_Get_Struct(self, struct string_slice, slice);
    return INT2FIX(slice->length);
 }
 static VALUE rb_slice_equal(VALUE self, VALUE other)
 {
    struct string_slice *this_slice;
    Data_Get_Struct(self, struct string_slice, this_slice);
    const char *other_str;
    long other_length;
    if (TYPE(other) == T_DATA && RBASIC_CLASS(other) == cLiquidStringSlice) {
        struct string_slice *other_slice = DATA_PTR(other);
        other_str = other_slice->str;
        other_length = other_slice->length;
    } else {
        other = rb_string_value(&other);
        other_length = RSTRING_LEN(other);
        other_str = RSTRING_PTR(other);
    }
    bool equal = this_slice->length == other_length && !memcmp(this_slice->str, other_str, other_length);
    return equal ? Qtrue : Qfalse;
 }
 static VALUE rb_slice_inspect(VALUE self)
 {
    VALUE quoted = rb_str_inspect(rb_slice_to_str(self));
    return rb_sprintf("#<Liquid::StringSlice: %.*s>", (int)RSTRING_LEN(quoted), RSTRING_PTR(quoted));
 }
 static VALUE rb_slice_join(VALUE klass, VALUE ary)
 {
    ary = rb_ary_to_ary(ary);
    long i;
    long result_length = 0;
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        VALUE element = RARRAY_AREF(ary, i);
        if (TYPE(element) == T_DATA && RBASIC_CLASS(element) == cLiquidStringSlice) {
            struct string_slice *slice = DATA_PTR(element);
            result_length += slice->length;
        } else if (TYPE(element) == T_STRING) {
            result_length += RSTRING_LEN(element);
        }
    }
    VALUE result = rb_str_buf_new(result_length);
    for (i = 0; i < RARRAY_LEN(ary); i++) {
        VALUE element = RARRAY_AREF(ary, i);
        const char *element_string;
        long element_length;
        if (TYPE(element) == T_DATA && RBASIC_CLASS(element) == cLiquidStringSlice) {
            struct string_slice *slice = DATA_PTR(element);
            element_string = slice->str;
            element_length = slice->length;
        } else if (NIL_P(element)) {
            continue;
        } else {
            element = rb_check_string_type(element);
            if (NIL_P(element))
                continue;
            element_string = RSTRING_PTR(element);
            element_length = RSTRING_LEN(element);
        }
        rb_str_buf_cat(result, element_string, element_length);
    }
    return result;
 }
 void init_liquid_string_slice()
 {
    cLiquidStringSlice = rb_define_class_under(mLiquid, "StringSlice", rb_cObject);
    rb_define_singleton_method(cLiquidStringSlice, "join", rb_slice_join, 1);
    rb_define_alloc_func(cLiquidStringSlice, rb_allocate);
    rb_define_method(cLiquidStringSlice, "initialize", rb_initialize, 3);
    rb_define_method(cLiquidStringSlice, "==", rb_slice_equal, 1);
    rb_define_method(cLiquidStringSlice, "length", rb_slice_length, 0);
    rb_define_alias(cLiquidStringSlice,  "size", "length");
    rb_define_method(cLiquidStringSlice, "slice", rb_slice_slice, 2);
    rb_define_method(cLiquidStringSlice, "to_str", rb_slice_to_str, 0);
    rb_define_alias(cLiquidStringSlice,  "to_s", "to_str");
    rb_define_method(cLiquidStringSlice, "inspect", rb_slice_inspect, 0);
 }
--- a/ext/liquid/slice.h
+++ b/ext/liquid/slice.h
@@ -0,0 +1,18 @@
 #ifndef LIQUID_SLICE_H
 #define LIQUID_SLICE_H
 extern VALUE cLiquidStringSlice;
 struct string_slice {
    VALUE source;
    const char *str;
    long length;
 };
 VALUE liquid_string_slice_new(const char *str, long length);
 void init_liquid_string_slice();
 #define STRING_SLICE_GET_STRUCT(obj) ((struct string_slice *)obj_get_data_ptr(obj, cLiquidStringSlice))
 #endif
--- a/ext/liquid/tokenizer.c
+++ b/ext/liquid/tokenizer.c
@@ -0,0 +1,113 @@
 #include "liquid_ext.h"
 VALUE cLiquidTokenizer;
 static void free_tokenizer(void *ptr)
 {
    struct liquid_tokenizer *tokenizer = ptr;
    xfree(tokenizer);
 }
 static VALUE rb_allocate(VALUE klass)
 {
    VALUE obj;
    struct liquid_tokenizer *tokenizer;
    obj = Data_Make_Struct(klass, struct liquid_tokenizer, NULL, free_tokenizer, tokenizer);
    return obj;
 }
 static VALUE rb_initialize(VALUE self, VALUE source)
 {
    struct liquid_tokenizer *tokenizer;
    source = rb_string_value(&source);
    Data_Get_Struct(self, struct liquid_tokenizer, tokenizer);
    tokenizer->cursor = RSTRING_PTR(source);
    tokenizer->length = RSTRING_LEN(source);
    return Qnil;
 }
 void liquid_tokenizer_next(struct liquid_tokenizer *tokenizer, struct token *token)
 {
    if (tokenizer->length <= 0) {
        memset(token, 0, sizeof(*token));
        return;
    }
    token->type = TOKEN_STRING;
    char *cursor = tokenizer->cursor;
    char *last = tokenizer->cursor + tokenizer->length - 1;
    while (cursor < last) {
        if (*cursor++ != '{')
            continue;
        char c = *cursor++;
        if (c != '%' && c != '{')
            continue;
        if (cursor - tokenizer->cursor > 2) {
            token->type = TOKEN_STRING;
            cursor -= 2;
            goto found;
        }
        char *incomplete_end = cursor;
        token->type = TOKEN_INVALID;
        if (c == '%') {
            while (cursor < last) {
                if (*cursor++ != '%')
                    continue;
                c = *cursor++;
                while (c == '%' && cursor <= last)
                    c = *cursor++;
                if (c != '}')
                    continue;
                token->type = TOKEN_TAG;
                goto found;
            }
            cursor = incomplete_end;
            goto found;
        } else {
            while (cursor < last) {
                if (*cursor++ != '}')
                    continue;
                if (*cursor++ != '}') {
                    incomplete_end = cursor - 1;
                    continue;
                }
                token->type = TOKEN_VARIABLE;
                goto found;
            }
            cursor = incomplete_end;
            goto found;
        }
    }
    cursor = last + 1;
 found:
    token->str = tokenizer->cursor;
    token->length = cursor - tokenizer->cursor;
    tokenizer->cursor += token->length;
    tokenizer->length -= token->length;
 }
 static VALUE rb_next(VALUE self)
 {
    struct liquid_tokenizer *tokenizer;
    Data_Get_Struct(self, struct liquid_tokenizer, tokenizer);
    struct token token;
    liquid_tokenizer_next(tokenizer, &token);
    if (token.type == TOKEN_NONE)
        return Qnil;
    return rb_str_new(token.str, token.length);
 }
 void init_liquid_tokenizer()
 {
    cLiquidTokenizer = rb_define_class_under(mLiquid, "Tokenizer", rb_cObject);
    rb_define_alloc_func(cLiquidTokenizer, rb_allocate);
    rb_define_method(cLiquidTokenizer, "initialize", rb_initialize, 1);
    rb_define_method(cLiquidTokenizer, "next", rb_next, 0);
    rb_define_alias(cLiquidTokenizer, "shift", "next");
 }
--- a/ext/liquid/tokenizer.h
+++ b/ext/liquid/tokenizer.h
@@ -0,0 +1,30 @@
 #ifndef LIQUID_TOKENIZER_H
 #define LIQUID_TOKENIZER_H
 extern VALUE cLiquidTokenizer;
 enum token_type {
    TOKEN_NONE,
    TOKEN_INVALID,
    TOKEN_STRING,
    TOKEN_TAG,
    TOKEN_VARIABLE
 };
 struct token {
    enum token_type type;
    char *str;
    int length;
 };
 struct liquid_tokenizer {
    char *cursor;
    int length;
 };
 void init_liquid_tokenizer();
 void liquid_tokenizer_next(struct liquid_tokenizer *tokenizer, struct token *token);
 #define LIQUID_TOKENIZER_GET_STRUCT(obj) ((struct liquid_tokenizer *)obj_get_data_ptr(obj, cLiquidTokenizer))
 #endif
--- a/ext/liquid/utils.c
+++ b/ext/liquid/utils.c
@@ -0,0 +1,21 @@
 #include <ruby.h>
 void raise_type_error(VALUE expected, VALUE got)
 {
    rb_raise(rb_eTypeError, "wrong argument type %s (expected %s)",
                             rb_class2name(got), rb_class2name(expected));
 }
 void check_class(VALUE obj, int type, VALUE klass)
 {
    Check_Type(obj, type);
    VALUE obj_klass = RBASIC_CLASS(obj);
    if (obj_klass != klass)
        raise_type_error(klass, obj_klass);
 }
 void *obj_get_data_ptr(VALUE obj, VALUE klass)
 {
    check_class(obj, T_DATA, klass);
    return DATA_PTR(obj);
 }
--- a/ext/liquid/utils.h
+++ b/ext/liquid/utils.h
@@ -0,0 +1,8 @@
 #ifndef LIQUID_UTILS_H
 #define LIQUID_UTILS_H
 void raise_type_error(VALUE expected, VALUE got);
 void check_class(VALUE klass);
 void *obj_get_data_ptr(VALUE obj, VALUE klass);
 #endif
--- a/init.rb
+++ b/init.rb
@@ -0,0 +1,8 @@
 require 'liquid'
 require 'extras/liquid_view'
 if defined? ActionView::Template and ActionView::Template.respond_to? :register_template_handler
  ActionView::Template
 else
  ActionView::Base
 end.register_template_handler(:liquid, LiquidView)
--- a/lib/extras/liquid_view.rb
+++ b/lib/extras/liquid_view.rb
@@ -0,0 +1,51 @@
 # LiquidView is a action view extension class. You can register it with rails
 # and use liquid as an template system for .liquid files
 #
 # Example
 #
 #   ActionView::Base::register_template_handler :liquid, LiquidView
 class LiquidView
  PROTECTED_ASSIGNS = %w( template_root response _session template_class action_name request_origin session template
                          _response url _request _cookies variables_added _flash params _headers request cookies
                          ignore_missing_templates flash _params logger before_filter_chain_aborted headers )
  PROTECTED_INSTANCE_VARIABLES = %w( @_request @controller @_first_render @_memoized__pick_template @view_paths
                                     @helpers @assigns_added @template @_render_stack @template_format @assigns )
  def self.call(template)
    "LiquidView.new(self).render(template, local_assigns)"
  end
  def initialize(view)
    @view = view
  end
  def render(template, local_assigns = nil)
    @view.controller.headers["Content-Type"] ||= 'text/html; charset=utf-8'
    # Rails 2.2 Template has source, but not locals
    if template.respond_to?(:source) && !template.respond_to?(:locals)
      assigns = (@view.instance_variables - PROTECTED_INSTANCE_VARIABLES).inject({}) do |hash, ivar|
                  hash[ivar[1..-1]] = @view.instance_variable_get(ivar)
                  hash
                end
    else
      assigns = @view.assigns.reject{ |k,v| PROTECTED_ASSIGNS.include?(k) }
    end
    source = template.respond_to?(:source) ? template.source : template
    local_assigns = (template.respond_to?(:locals) ? template.locals : local_assigns) || {}
    if content_for_layout = @view.instance_variable_get("@content_for_layout")
      assigns['content_for_layout'] = content_for_layout
    end
    assigns.merge!(local_assigns.stringify_keys)
    liquid = Liquid::Template.parse(source)
    liquid.render(assigns, :filters => [@view.controller.master_helper_module], :registers => {:action_view => @view, :controller => @view.controller})
  end
  def compilable?
    false
  end
 end
--- a/lib/liquid.rb
+++ b/lib/liquid.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 # Copyright (c) 2005 Tobias Luetke
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -26,59 +24,46 @@ module Liquid
  ArgumentSeparator           = ','
  FilterArgumentSeparator     = ':'
  VariableAttributeSeparator  = '.'
  WhitespaceControl           = '-'
  TagStart                    = /\{\%/
  TagEnd                      = /\%\}/
  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
  VariableSegment             = /[\w\-]/
  VariableStart               = /\{\{/
  VariableEnd                 = /\}\}/
  VariableIncompleteEnd       = /\}\}?/
  QuotedString                = /"[^"]*"|'[^']*'/
  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
  StrictQuotedFragment        = /"[^"]+"|'[^']+'|[^\s|:,]+/
  FirstFilterArgument         = /#{FilterArgumentSeparator}(?:#{StrictQuotedFragment})/o
  OtherFilterArgument         = /#{ArgumentSeparator}(?:#{StrictQuotedFragment})/o
  SpacelessFilter             = /\A(?:'[^']+'|"[^"]+"|[^'"])*#{FilterSeparator}(?:#{StrictQuotedFragment})(?:#{FirstFilterArgument}(?:#{OtherFilterArgument})*)?/o
  Expression                  = /(?:#{QuotedFragment}(?:#{SpacelessFilter})*)/o
  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
  singleton_class.send(:attr_accessor, :cache_classes)
  self.cache_classes = true
 end
 require 'liquid/liquid'
 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/htmltags'
 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'
 # Load all the tags of the standard library
 #
-Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
--- a/lib/liquid/block.rb
+++ b/lib/liquid/block.rb
@@ -1,80 +1,101 @@
 # frozen_string_literal: true
 module Liquid
  class Block < Tag
-    MAX_DEPTH = 100
+    def initialize(tag_name, markup, tokens)
    def initialize(tag_name, markup, options)
      super
-      @blank = true
+      parse_body(tokens)
    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
+      @blank || false
    end
-    def nodelist
+    # warnings of this block and all sub-tags
-      @body.nodelist
+    def warnings
-    end
+      all_warnings = []
      all_warnings.concat(@warnings) if @warnings
-    def unknown_tag(tag, _params, _tokens)
+      (nodelist || []).each do |node|
-      if tag == 'else'
+        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else",
          block_name: block_name)
      elsif tag.start_with?('end')
        raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter",
          tag: tag,
          block_name: block_name,
          block_delimiter: block_delimiter)
      else
        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
      end
      all_warnings
    end
    def unknown_tag(tag, params, tokens)
      case tag
      when 'else'
        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else", 
                                                 :block_name => block_name))
      when 'end'
        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter", 
                                                 :block_name => block_name, 
                                                 :block_delimiter => block_delimiter))
      else
        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag", :tag => tag))
      end
    end
    def block_delimiter
      "end#{block_name}"
    end
    def block_name
      @tag_name
    end
-    def block_delimiter
+    def render(context)
-      @block_delimiter ||= "end#{block_name}"
+      render_all(@nodelist, context)
    end
    protected
-    def parse_body(body, tokens)
+    def unterminated_variable(token)
-      if parse_context.depth >= MAX_DEPTH
+      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination", :token => token, :tag_end => VariableEnd.inspect))
-        raise StackLevelError, "Nesting too deep"
+    end
      end
      parse_context.depth += 1
      begin
        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
          @blank &&= body.blank?
-          return false if end_tag_name == block_delimiter
+    def unterminated_tag(token)
-          unless end_tag_name
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination", :token => token, :tag_end => TagEnd.inspect))
-            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+    end
    def assert_missing_delimitation!
      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_never_closed", :block_name => block_name))
    end
    def render_all(list, context)
      output = []
      context.resource_limits[:render_length_current] = 0
      context.resource_limits[:render_score_current] += list.length
      list.each do |token|
        # Break out if we have any unhanded interrupts.
        break if context.has_interrupt?
        begin
          # If we get an Interrupt that means the block must stop processing. An
          # Interrupt is any command that stops block execution such as {% break %}
          # or {% continue %}
          if token.is_a? Continue or token.is_a? Break
            context.push_interrupt(token.interrupt)
            break
          end
-          # this tag is not registered with the system
+          token_output = (token.respond_to?(:render) ? token.render(context) : token)
-          # pass it to the current block for special handling or error reporting
+          context.increment_used_resources(:render_length_current, token_output)
-          unknown_tag(end_tag_name, end_tag_params, tokens)
+          if context.resource_limits_reached?
            context.resource_limits[:reached] = true
            raise MemoryError.new("Memory limits exceeded")
          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
-      true
+      StringSlice.join(output)
    end
  end
 end
--- a/lib/liquid/block_body.rb
+++ b/lib/liquid/block_body.rb
@@ -1,191 +0,0 @@
 # 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)
      node.render_to_output_buffer(context, output)
    rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
      context.handle_error(e, node.line_number)
    rescue ::StandardError => e
      line_number = node.is_a?(String) ? nil : node.line_number
      output << context.handle_error(e, line_number)
    end
    def raise_if_resource_limits_reached(context, length)
      context.resource_limits.render_length += length
      return unless context.resource_limits.reached?
      raise MemoryError, "Memory limits exceeded"
    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
--- a/lib/liquid/condition.rb
+++ b/lib/liquid/condition.rb
@@ -1,74 +1,55 @@
 # 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 = {
-      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<' => :<,
+      '<'  => :<,
-      '>' => :>,
+      '>'  => :>,
      '>=' => :>=,
      '<=' => :<=,
-      'contains' => lambda do |_cond, left, right|
+      'contains' => lambda { |cond, left, right| left && right ? left.include?(right) : false }
        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, :child_condition
+    attr_reader :attachment
    attr_accessor :left, :operator, :right
    def initialize(left = nil, operator = nil, right = nil)
-      @left = left
+      @left, @operator, @right = left, operator, right
-      @operator = operator
+      @child_relation  = nil
      @right = right
      @child_relation = nil
      @child_condition = nil
    end
    def evaluate(context = Context.new)
-      condition = self
+      result = interpret_condition(left, right, operator, context)
      result = nil
      loop do
        result = interpret_condition(condition.left, condition.right, condition.operator, context)
-        case condition.child_relation
+      case @child_relation
-        when :or
+      when :or
-          break if result
+        result || @child_condition.evaluate(context)
-        when :and
+      when :and
-          break unless result
+        result && @child_condition.evaluate(context)
-        else
+      else
-          break
+        result
        end
        condition = condition.child_condition
      end
      result
    end
    def or(condition)
-      @child_relation = :or
+      @child_relation, @child_condition = :or, condition
      @child_condition = condition
    end
    def and(condition)
-      @child_relation = :and
+      @child_relation, @child_condition = :and, condition
      @child_condition = condition
    end
    def attach(attachment)
@@ -83,24 +64,20 @@ module Liquid
      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
    end
    protected
    attr_reader :child_relation
    private
    def equal_variables(left, right)
-      if left.is_a?(Liquid::Expression::MethodLiteral)
+      if left.is_a?(Symbol)
-        if right.respond_to?(left.method_name)
+        if right.respond_to?(left)
-          return right.send(left.method_name)
+          return right.send(left.to_s)
        else
          return nil
        end
      end
-      if right.is_a?(Liquid::Expression::MethodLiteral)
+      if right.is_a?(Symbol)
-        if left.respond_to?(right.method_name)
+        if left.respond_to?(right)
-          return left.send(right.method_name)
+          return left.send(right.to_s)
        else
          return nil
        end
@@ -113,41 +90,31 @@ module Liquid
      # If the operator is empty this means that the decision statement is just
      # a single variable. We can just poll this variable from the context and
      # return this as the result.
-      return context.evaluate(left) if op.nil?
+      return context[left] if op == nil
-      left = context.evaluate(left)
+      left, right = context[left], context[right]
      right = context.evaluate(right)
-      operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
+      operation = self.class.operators[op] || raise(ArgumentError.new("Unknown operator #{op}"))
      if operation.respond_to?(:call)
        operation.call(self, left, right)
-      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
+      elsif left.respond_to?(operation) and right.respond_to?(operation)
-        begin
+        left.send(operation, right)
-          left.send(operation, right)
+      else
-        rescue ::ArgumentError => e
+        nil
          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
--- a/lib/liquid/context.rb
+++ b/lib/liquid/context.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Context keeps the variable stack and resolves variables, as well as keywords
  #
  #   context['variable'] = 'testing'
@@ -14,42 +13,33 @@ module Liquid
  #
  #   context['bob']  #=> nil  class Context
  class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
-    # rubocop:disable Metrics/ParameterLists
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
-    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_registers: {}, static_environments: {})
+      @environments    = [environments].flatten
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_registers, static_environments)
+      @scopes          = [(outer_scope || {})]
-    end
+      @registers       = registers
-
+      @errors          = []
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_registers = {}, static_environments = {})
+      @rethrow_errors  = rethrow_errors
-      @environments = [environments]
+      @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
      @environments.flatten!
      @static_environments = [static_environments].flat_map(&:freeze).freeze
      @scopes              = [(outer_scope || {})]
      @registers           = registers
      @static_registers    = static_registers.freeze
      @errors              = []
      @partial             = false
      @strict_variables    = false
      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
      @base_scope_depth    = 0
      squash_instance_assigns_with_environments
      self.exception_renderer = Template.default_exception_renderer
      if rethrow_errors
        self.exception_renderer = ->(_e) { raise }
      end
      @interrupts = []
      @filters = []
      @global_filter = nil
    end
    # rubocop:enable Metrics/ParameterLists
-    def warnings
+    def increment_used_resources(key, obj)
-      @warnings ||= []
+      @resource_limits[key] += if obj.kind_of?(StringSlice) || obj.kind_of?(String) || obj.kind_of?(Array) || obj.kind_of?(Hash)
        obj.length
      else
        1
      end
    end
    def resource_limits_reached?
      (@resource_limits[:render_length_limit] && @resource_limits[:render_length_current] > @resource_limits[:render_length_limit]) ||
      (@resource_limits[:render_score_limit]  && @resource_limits[:render_score_current]  > @resource_limits[:render_score_limit] ) ||
      (@resource_limits[:assign_score_limit]  && @resource_limits[:assign_score_current]  > @resource_limits[:assign_score_limit] )
    end
    def strainer
@@ -62,17 +52,26 @@ module Liquid
    # for that
    def add_filters(filters)
      filters = [filters].flatten.compact
-      @filters += filters
+      filters.each do |f|
-      @strainer = nil
+        raise ArgumentError, "Expected module but got: #{f.class}" unless f.is_a?(Module)
-    end
+        Strainer.add_known_filter(f)
      end
-    def apply_global_filter(obj)
+      # If strainer is already setup then there's no choice but to use a runtime
-      global_filter.nil? ? obj : global_filter.call(obj)
+      # extend call. If strainer is not yet created, we can utilize strainers
      # cached class based API, which avoids busting the method cache.
      if @strainer
        filters.each do |f|
          strainer.extend(f)
        end
      else
        @filters.concat filters
      end
    end
    # are there any not handled interrupts?
-    def interrupt?
+    def has_interrupt?
-      !@interrupts.empty?
+      @interrupts.any?
    end
    # push an interrupt to the stack. this interrupt is considered not handled.
@@ -85,22 +84,26 @@ module Liquid
      @interrupts.pop
    end
-    def handle_error(e, line_number = nil)
+    def handle_error(e)
      e = internal_error unless e.is_a?(Liquid::Error)
      e.template_name ||= template_name
      e.line_number ||= line_number
      errors.push(e)
-      exception_renderer.call(e).to_s
+      raise if @rethrow_errors
      case e
      when SyntaxError
        "Liquid syntax error: #{e.message}"
      else
        "Liquid error: #{e.message}"
      end
    end
    def invoke(method, *args)
-      strainer.invoke(method, *args).to_liquid
+      strainer.invoke(method, *args)
    end
    # Push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push(new_scope = {})
+    def push(new_scope={})
      @scopes.unshift(new_scope)
-      check_overflow
+      raise StackLevelError, "Nesting too deep" if @scopes.length > 100
    end
    # Merge a hash of variables in the current local scope
@@ -122,32 +125,13 @@ 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,
        static_registers: static_registers
      ).tap do |subcontext|
        subcontext.base_scope_depth = base_scope_depth + 1
        subcontext.exception_renderer = exception_renderer
        subcontext.filters = @filters
        subcontext.strainer = nil
        subcontext.errors = errors
        subcontext.warnings = warnings
      end
    end
    def clear_instance_assigns
      @scopes[0] = {}
    end
@@ -157,106 +141,145 @@ module Liquid
      @scopes[0][key] = value
    end
-    # Look up variable, either resolve directly after considering the name. We can directly handle
+    def [](key)
-    # Strings, digits, floats and booleans (true,false).
+      resolve(key)
    # 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 key?(key)
+    def has_key?(key)
-      self[key] != nil
+      resolve(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' => nil, 'null' => nil, '' => nil,
        'true'  => true,
        'false' => false,
        'blank' => :blank?,
        'empty' => :empty?
      }
-    attr_reader :base_scope_depth
+      # Look up variable, either resolve directly after considering the name. We can directly handle
-
+      # Strings, digits, floats and booleans (true,false).
-    def try_variable_find_in_environments(key, raise_on_not_found:)
+      # If no match is made we lookup the variable in the current scope and
-      @environments.each do |environment|
+      # later move up to the parent blocks to see if we can resolve the variable somewhere up the tree.
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+      # Some special keywords return symbols. Those symbols are to be called on the rhs object in expressions
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
+      #
-          return found_variable
+      # Example:
-        end
+      #   products == empty #=> products.empty?
-      end
+      def resolve(key)
-      @static_environments.each do |environment|
+        if LITERALS.key?(key)
-        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+          LITERALS[key]
-        if !found_variable.nil? || @strict_variables && raise_on_not_found
+        else
-          return found_variable
+          case key
-        end
+          when /\A'(.*)'\z/ # Single quoted strings
-      end
+            $1
-      nil
+          when /\A"(.*)"\z/ # Double quoted strings
-    end
+            $1
-
+          when /\A(-?\d+)\z/ # Integer and floats
-    def check_overflow
+            $1.to_i
-      raise StackLevelError, "Nesting too deep" if overflow?
+          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
-    end
+            (resolve($1).to_i..resolve($2).to_i)
-
+          when /\A(-?\d[\d\.]+)\z/ # Floats
-    def overflow?
+            $1.to_f
-      base_scope_depth + @scopes.length > Block::MAX_DEPTH
+          else
-    end
+            variable(key)
    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)
        scope = @scopes.find { |s| s.has_key?(key) }
        variable = nil
        if scope.nil?
          @environments.each do |e|
            if variable = lookup_and_evaluate(e, key)
              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
      # 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 = markup.scan(VariableParser)
        square_bracketed = /\A\[(.*)\]\z/
        first_part = parts.shift
        if first_part =~ square_bracketed
          first_part = resolve($1)
        end
        if object = find_variable(first_part)
          parts.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', 'first', 'last'].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
--- a/lib/liquid/document.rb
+++ b/lib/liquid/document.rb
@@ -1,29 +1,18 @@
 # frozen_string_literal: true
 module Liquid
-  class Document < BlockBody
+  class Document < Block
-    def self.parse(tokens, parse_context)
+    # we don't need markup to open this block
-      doc = new
+    def initialize(tokens, options = {})
-      doc.parse(tokens, parse_context)
+      @options = options
-      doc
+      parse_body(tokens)
    end
-    def parse(tokens, parse_context)
+    # There isn't a real delimiter
-      super do |end_tag_name, _end_tag_params|
+    def block_delimiter
-        unknown_tag(end_tag_name, parse_context) if end_tag_name
+      nil
      end
    rescue SyntaxError => e
      e.line_number ||= parse_context.line_number
      raise
    end
-    def unknown_tag(tag, parse_context)
+    # Document blocks don't need to be terminated since they are not actually opened
-      case tag
+    def assert_missing_delimitation!
      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
--- a/lib/liquid/drop.rb
+++ b/lib/liquid/drop.rb
@@ -1,8 +1,7 @@
 # frozen_string_literal: true
 require 'set'
 module Liquid
  # A drop in liquid is a class which allows you to export DOM like things to liquid.
  # Methods of drops are callable.
  # The main use for liquid drops is to implement lazy loaded objects.
@@ -20,27 +19,28 @@ module Liquid
  #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
  #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
  #
-  # Your drop can either implement the methods sans any parameters
+  # Your drop can either implement the methods sans any parameters or implement the before_method(name) method which is a
-  # or implement the liquid_method_missing(name) method which is a catch all.
+  # catch all.
  class Drop
    attr_writer :context
    EMPTY_STRING = ''.freeze
    # Catch all for the method
-    def liquid_method_missing(method)
+    def before_method(method)
-      return nil unless @context&.strict_variables
+      nil
      raise Liquid::UndefinedDropMethod, "undefined method #{method}"
    end
    # called by liquid to invoke a drop
    def invoke_drop(method_or_key)
-      if self.class.invokable?(method_or_key)
+      if method_or_key && method_or_key != EMPTY_STRING && self.class.invokable?(method_or_key)
        send(method_or_key)
      else
-        liquid_method_missing(method_or_key)
+        before_method(method_or_key)
      end
    end
-    def key?(_name)
+    def has_key?(name)
      true
    end
@@ -56,25 +56,22 @@ module Liquid
      self.class.name
    end
-    alias_method :[], :invoke_drop
+    alias :[] :invoke_drop
    private
    # Check for method existence without invoking respond_to?, which creates symbols
    def self.invokable?(method_name)
-      invokable_methods.include?(method_name.to_s)
+      unless @invokable_methods
    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?]
        end
        whitelist = [:to_liquid] + (public_instance_methods - blacklist)
-        Set.new(whitelist.map(&:to_s))
+        @invokable_methods = Set.new(whitelist.map(&:to_s))
      end
      @invokable_methods.include?(method_name.to_s)
    end
  end
 end
--- a/lib/liquid/errors.rb
+++ b/lib/liquid/errors.rb
@@ -1,58 +1,12 @@
 # frozen_string_literal: true
 module Liquid
-  class Error < ::StandardError
+  class Error < ::StandardError; end
    attr_accessor :line_number
    attr_accessor :template_name
    attr_accessor :markup_context
-    def to_s(with_prefix = true)
+  class ArgumentError < Error; end
-      str = +""
+  class ContextError < Error; end
-      str << message_prefix if with_prefix
+  class FilterNotFound < Error; end
-      str << super()
+  class FileSystemError < Error; end
-
+  class StandardError < Error; end
-      if markup_context
+  class SyntaxError < Error; end
-        str << " "
+  class StackLevelError < Error; end
-        str << markup_context
+  class MemoryError < Error; end
      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
--- a/lib/liquid/expression.rb
+++ b/lib/liquid/expression.rb
@@ -1,51 +0,0 @@
 # 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
--- a/lib/liquid/extensions.rb
+++ b/lib/liquid/extensions.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 require 'time'
 require 'date'
@@ -9,56 +7,44 @@ class String # :nodoc:
  end
 end
-class Symbol # :nodoc:
+class Array  # :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 Range # :nodoc:
+class Time  # :nodoc:
  def to_liquid
    self
  end
 end
-class Time # :nodoc:
+class DateTime < Date  # :nodoc:
  def to_liquid
    self
  end
 end
-class DateTime < Date # :nodoc:
+class 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
--- a/lib/liquid/file_system.rb
+++ b/lib/liquid/file_system.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag.
  #
@@ -10,13 +8,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)
+    def read_template_file(template_path, context)
      raise FileSystemError, "This liquid context does not allow includes."
    end
  end
@@ -28,10 +26,10 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path")
+  # file_system = Liquid::LocalFileSystem.new("/some/path")
  #
-  #   file_system.full_path("mypartial")       # => "/some/path/_mypartial.liquid"
+  # file_system.full_path("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.
@@ -39,9 +37,9 @@ module Liquid
  #
  # Example:
  #
-  #   file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
+  # file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
  #
-  #   file_system.full_path("index") # => "/some/path/index.html"
+  # file_system.full_path("index") # => "/some/path/index.html"
  #
  class LocalFileSystem
    attr_accessor :root
@@ -51,15 +49,15 @@ module Liquid
      @pattern = pattern
    end
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
      full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
      File.read(full_path)
    end
    def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ %r{\A[^./][a-zA-Z0-9_/]+\z}
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
      full_path = if template_path.include?('/')
        File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
@@ -67,7 +65,7 @@ module Liquid
        File.join(root, @pattern % template_path)
      end
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path).start_with?(File.expand_path(root))
+      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path) =~ /\A#{File.expand_path(root)}/
      full_path
    end
--- a/lib/liquid/forloop_drop.rb
+++ b/lib/liquid/forloop_drop.rb
@@ -1,44 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class ForloopDrop < Drop
    def initialize(name, length, parentloop)
      @name = name
      @length = length
      @parentloop = parentloop
      @index = 0
    end
    attr_reader :name, :length, :parentloop
    def index
      @index + 1
    end
    def index0
      @index
    end
    def rindex
      @length - @index
    end
    def rindex0
      @length - @index - 1
    end
    def first
      @index == 0
    end
    def last
      @index == @length - 1
    end
    protected
    def increment!
      @index += 1
    end
  end
 end
--- a/lib/liquid/htmltags.rb
+++ b/lib/liquid/htmltags.rb
@@ -0,0 +1,74 @@
 module Liquid
  class TableRow < Block
    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
    def initialize(tag_name, markup, tokens)
      if markup =~ Syntax
        @variable_name = $1
        @collection_name = $2
        @attributes = {}
        markup.scan(TagAttributes) do |key, value|
          @attributes[key] = value
        end
      else
        raise SyntaxError.new(options[:locale].t("errors.syntax.table_row"))
      end
      super
    end
    def render(context)
      collection = context[@collection_name] or return ''
      from = @attributes['offset'] ? context[@attributes['offset']].to_i : 0
      to = @attributes['limit'] ? from + context[@attributes['limit']].to_i : nil
      collection = Utils.slice_collection(collection, from, to)
      length = collection.length
      cols = context[@attributes['cols']].to_i
      row = 1
      col = 0
      result = "<tr class=\"row1\">\n"
      context.stack do
        collection.each_with_index do |item, index|
          context[@variable_name] = item
          context['tablerowloop'] = {
            'length'  => length,
            'index'   => index + 1,
            'index0'  => index,
            'col'     => col + 1,
            'col0'    => col,
            'index0'  => index,
            'rindex'  => length - index,
            'rindex0' => length - index - 1,
            'first'   => (index == 0),
            'last'    => (index == length - 1),
            'col_first' => (col == 0),
            'col_last'  => (col == cols - 1)
          }
          col += 1
          result << "<td class=\"col#{col}\">" << super << '</td>'
          if col == cols and (index != length - 1)
            col  = 0
            row += 1
            result << "</tr>\n<tr class=\"row#{row}\">"
          end
        end
      end
      result << "</tr>\n"
      result
    end
  end
  Template.register_tag('tablerow', TableRow)
 end
--- a/lib/liquid/i18n.rb
+++ b/lib/liquid/i18n.rb
@@ -1,12 +1,11 @@
 # frozen_string_literal: true
 require 'yaml'
 module Liquid
  class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
+    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
-    TranslationError = Class.new(StandardError)
+    class TranslationError < StandardError
    end
    attr_reader :path
@@ -24,17 +23,16 @@ module Liquid
    end
    private
    def interpolate(name, vars)
-      name.gsub(/%\{(\w+)\}/) do
+      name.gsub(/%\{(\w+)\}/) {
        # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        (vars[Regexp.last_match(1).to_sym]).to_s
+        "#{vars[$1.to_sym]}"
-      end
+      }
    end
    def deep_fetch_translation(name)
      name.split('.').reduce(locale) do |level, cur|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
      end
    end
  end
--- a/lib/liquid/interrupts.rb
+++ b/lib/liquid/interrupts.rb
@@ -1,11 +1,10 @@
 # frozen_string_literal: true
 module Liquid
  # An interrupt is any command that breaks processing of a block (ex: a for loop).
  class Interrupt
    attr_reader :message
-    def initialize(message = nil)
+    def initialize(message=nil)
      @message = message || "interrupt"
    end
  end
--- a/lib/liquid/lexer.rb
+++ b/lib/liquid/lexer.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 require "strscan"
 module Liquid
  class Lexer
@@ -11,38 +9,35 @@ module Liquid
      '[' => :open_square,
      ']' => :close_square,
      '(' => :open_round,
-      ')' => :close_round,
+      ')' => :close_round
-      '?' => :question,
+    }
-      '-' => :dash,
+    IDENTIFIER = /[\w\-?!]+/
    }.freeze
    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
    SINGLE_STRING_LITERAL = /'[^\']*'/
    DOUBLE_STRING_LITERAL = /"[^\"]*"/
    NUMBER_LITERAL = /-?\d+(\.\d+)?/
    DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
    WHITESPACE_OR_NOTHING = /\s*/
    def initialize(input)
-      @ss = StringScanner.new(input)
+      @ss = StringScanner.new(input.rstrip)
    end
    def tokenize
      @output = []
-      until @ss.eos?
+      while !@ss.eos?
-        @ss.skip(WHITESPACE_OR_NOTHING)
+        @ss.skip(/\s*/)
-        break if @ss.eos?
+        tok = case
-        tok = if t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
-        elsif t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
-        elsif t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
-        elsif t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
-        elsif t = @ss.scan(IDENTIFIER) then [:id, t]
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
-        elsif t = @ss.scan(DOTDOT) then [:dotdot, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
        else
          c = @ss.getch
          if s = SPECIALS[c]
-            [s, c]
+            [s,c]
          else
            raise SyntaxError, "Unexpected character #{c}"
          end
--- a/lib/liquid/locales/en.yml
+++ b/lib/liquid/locales/en.yml
@@ -1,7 +1,6 @@
 ---
  errors:
    syntax:
      tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: %{tag}"
      assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
      capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
      case: "Syntax Error in 'case' - Valid syntax: case [condition]"
@@ -14,14 +13,10 @@
      if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
      include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
      unknown_tag: "Unknown tag '%{tag}'"
-      invalid_delimiter: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
-      unexpected_else: "%{block_name} tag does not expect 'else' tag"
+      unexpected_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"
--- a/lib/liquid/module_ex.rb
+++ b/lib/liquid/module_ex.rb
@@ -0,0 +1,62 @@
 # Copyright 2007 by Domizio Demichelis
 # This library is free software. It may be used, redistributed and/or modified
 # under the same terms as Ruby itself
 #
 # This extension is used in order to expose the object of the implementing class
 # to liquid as it were a Drop. It also limits the liquid-callable methods of the instance
 # to the allowed method passed with the liquid_methods call
 # Example:
 #
 # class SomeClass
 #   liquid_methods :an_allowed_method
 #
 #   def an_allowed_method
 #     'this comes from an allowed method'
 #   end
 #   def unallowed_method
 #     'this will never be an output'
 #   end
 # end
 #
 # if you want to extend the drop to other methods you can defines more methods
 # in the class <YourClass>::LiquidDropClass
 #
 #   class SomeClass::LiquidDropClass
 #     def another_allowed_method
 #       'and this from another allowed method'
 #     end
 #   end
 # end
 #
 # usage:
 # @something = SomeClass.new
 #
 # template:
 # {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
 #
 # output:
 # 'this comes from an allowed method and this from another allowed method'
 #
 # You can also chain associations, by adding the liquid_method call in the
 # association models.
 #
 class Module
  def liquid_methods(*allowed_methods)
    drop_class = eval "class #{self.to_s}::LiquidDropClass < Liquid::Drop; self; end"
    define_method :to_liquid do
      drop_class.new(self)
    end
    drop_class.class_eval do
      def initialize(object)
        @object = object
      end
      allowed_methods.each do |sym|
        define_method sym do
          @object.send sym
        end
      end
    end
  end
 end
--- a/lib/liquid/parse_context.rb
+++ b/lib/liquid/parse_context.rb
@@ -1,40 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class ParseContext
    attr_accessor :locale, :line_number, :trim_whitespace, :depth
    attr_reader :partial, :warnings, :error_mode
    def initialize(options = {})
      @template_options = options ? options.dup : {}
      @locale = @template_options[:locale] ||= I18n.new
      @warnings = []
      self.depth = 0
      self.partial = false
    end
    def [](option_key)
      @options[option_key]
    end
    def partial=(value)
      @partial = value
      @options = value ? partial_options : @template_options
      @error_mode = @options[:error_mode] || Template.error_mode
      value
    end
    def partial_options
      @partial_options ||= begin
        dont_pass = @template_options[:include_options_blacklist]
        if dont_pass == true
          { locale: locale }
        elsif dont_pass.is_a?(Array)
          @template_options.reject { |k, _v| dont_pass.include?(k) }
        else
          @template_options
        end
      end
    end
  end
 end
--- a/lib/liquid/parse_tree_visitor.rb
+++ b/lib/liquid/parse_tree_visitor.rb
@@ -1,42 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class ParseTreeVisitor
    def self.for(node, callbacks = Hash.new(proc {}))
      if defined?(node.class::ParseTreeVisitor)
        node.class::ParseTreeVisitor
      else
        self
      end.new(node, callbacks)
    end
    def initialize(node, callbacks)
      @node = node
      @callbacks = callbacks
    end
    def add_callback_for(*classes, &block)
      callback = block
      callback = ->(node, _) { yield node } if block.arity.abs == 1
      callback = ->(_, _) { yield } if block.arity.zero?
      classes.each { |klass| @callbacks[klass] = callback }
      self
    end
    def visit(context = nil)
      children.map do |node|
        item, new_context = @callbacks[node.class].call(node, context)
        [
          item,
          ParseTreeVisitor.for(node, @callbacks).visit(new_context || context),
        ]
      end
    end
    protected
    def children
      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : []
    end
  end
 end
--- a/lib/liquid/parser.rb
+++ b/lib/liquid/parser.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  class Parser
    def initialize(input)
@@ -46,14 +44,11 @@ module Liquid
      tok[0] == type
    end
    SINGLE_TOKEN_EXPRESSION_TYPES = [:string, :number].freeze
    private_constant :SINGLE_TOKEN_EXPRESSION_TYPES
    def expression
      token = @tokens[@p]
      if token[0] == :id
        variable_signature
-      elsif SINGLE_TOKEN_EXPRESSION_TYPES.include?(token[0])
+      elsif [:string, :number].include? token[0]
        consume
      elsif token.first == :open_round
        consume
@@ -68,19 +63,18 @@ module Liquid
    end
    def argument
-      str = +""
+      str = ""
      # might be a keyword argument (identifier: expression)
      if look(:id) && look(:colon, 1)
        str << consume << consume << ' '
      end
      str << expression
      str
    end
    def variable_signature
      str = consume(:id)
-      while look(:open_square)
+      if look(:open_square)
        str << consume
        str << expression
        str << consume(:close_square)
--- a/lib/liquid/parser_switching.rb
+++ b/lib/liquid/parser_switching.rb
@@ -1,33 +0,0 @@
 # 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
--- a/lib/liquid/partial_cache.rb
+++ b/lib/liquid/partial_cache.rb
@@ -1,20 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class PartialCache
    def self.load(template_name, context:, parse_context:)
      cached_partials = (context.registers[:cached_partials] ||= {})
      cached = cached_partials[template_name]
      return cached if cached
      file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
      source = file_system.read_template_file(template_name)
      parse_context.partial = true
      partial = Liquid::Template.parse(source, parse_context)
      cached_partials[template_name] = partial
    ensure
      parse_context.partial = false
    end
  end
 end
--- a/lib/liquid/profiler.rb
+++ b/lib/liquid/profiler.rb
@@ -1,160 +0,0 @@
 # 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
      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
      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_stack = ["<root>"]
      @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
--- a/lib/liquid/profiler/hooks.rb
+++ b/lib/liquid/profiler/hooks.rb
@@ -1,25 +0,0 @@
 # 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
--- a/lib/liquid/range_lookup.rb
+++ b/lib/liquid/range_lookup.rb
@@ -1,39 +0,0 @@
 # 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
--- a/lib/liquid/resource_limits.rb
+++ b/lib/liquid/resource_limits.rb
@@ -1,25 +0,0 @@
 # 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
--- a/lib/liquid/standardfilters.rb
+++ b/lib/liquid/standardfilters.rb
@@ -1,27 +1,15 @@
 # frozen_string_literal: true
 require 'cgi'
 require 'bigdecimal'
 module Liquid
  module StandardFilters
-    HTML_ESCAPE = {
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }
      '&' => '&amp;',
      '>' => '&gt;',
      '<' => '&lt;',
      '"' => '&quot;',
      "'" => '&#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)
      input.respond_to?(:size) ? input.size : 0
    end
@@ -41,56 +29,29 @@ module Liquid
    end
    def escape(input)
-      CGI.escapeHTML(input.to_s).untaint unless input.nil?
+      CGI.escapeHTML(input) rescue input
    end
    alias_method :h, :escape
    def escape_once(input)
      input.to_s.gsub(HTML_ESCAPE_ONCE_REGEXP, HTML_ESCAPE)
    end
-    def url_encode(input)
+    alias_method :h, :escape
      CGI.escape(input.to_s) unless input.nil?
    end
    def url_decode(input)
      return if input.nil?
      result = CGI.unescape(input.to_s)
      raise Liquid::ArgumentError, "invalid byte sequence in #{result.encoding}" unless result.valid_encoding?
      result
    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?
+      if input.nil? then return end
-      input_str = input.to_s
+      l = length.to_i - truncate_string.length
      length = Utils.to_integer(length)
      truncate_string_str = truncate_string.to_s
      l = length - truncate_string_str.length
      l = 0 if l < 0
-      input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
+      input.length > length.to_i ? input[0...l] + truncate_string : input
    end
    def truncatewords(input, words = 15, truncate_string = "...")
-      return if input.nil?
+      if input.nil? then return end
      wordlist = input.to_s.split
-      words = Utils.to_integer(words)
+      l = words.to_i - 1
      l = words - 1
      l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ").concat(truncate_string.to_s) : input
+      wordlist.length > l ? wordlist[0..l].join(" ") + truncate_string : input
    end
    # Split input string into an array of substrings separated by given pattern.
@@ -99,7 +60,7 @@ module Liquid
    #   <div class="summary">{{ post | split '//' | first }}</div>
    #
    def split(input, pattern)
-      input.to_s.split(pattern.to_s)
+      input.split(pattern)
    end
    def strip(input)
@@ -115,10 +76,7 @@ module Liquid
    end
    def strip_html(input)
-      empty = ''
+      input.to_s.gsub(/<script.*?<\/script>/m, '').gsub(/<!--.*?-->/m, '').gsub(/<style.*?<\/style>/m, '').gsub(/<.*?>/m, '')
      result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
      result.gsub!(STRIP_HTML_TAGS, empty)
      result
    end
    # Remove all newlines from the string
@@ -128,147 +86,59 @@ module Liquid
    # Join elements of the array with certain character between them
    def join(input, glue = ' ')
-      InputIterator.new(input).join(glue)
+      [input].flatten.join(glue)
    end
    # Sort elements of the array
    # provide optional property with which to sort an array of hashes or drops
    def sort(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = flatten_if_necessary(input)
      return [] if ary.empty?
      if property.nil?
-        ary.sort do |a, b|
+        ary.sort
-          nil_safe_compare(a, b)
+      elsif ary.first.respond_to?('[]') and !ary.first[property].nil?
-        end
+        ary.sort {|a,b| a[property] <=> b[property] }
-      elsif ary.all? { |el| el.respond_to?(:[]) }
+      elsif ary.first.respond_to?(property)
-        begin
+        ary.sort {|a,b| a.send(property) <=> b.send(property) }
          ary.sort { |a, b| nil_safe_compare(a[property], b[property]) }
        rescue TypeError
          raise_property_error(property)
        end
      end
    end
    # Sort elements of an array ignoring case if strings
    # provide optional property with which to sort an array of hashes or drops
    def sort_natural(input, property = nil)
      ary = InputIterator.new(input)
      return [] if ary.empty?
      if property.nil?
        ary.sort do |a, b|
          nil_safe_casecmp(a, b)
        end
      elsif ary.all? { |el| el.respond_to?(:[]) }
        begin
          ary.sort { |a, b| nil_safe_casecmp(a[property], b[property]) }
        rescue TypeError
          raise_property_error(property)
        end
      end
    end
    # Filter the elements of an array to those with a certain property value.
    # By default the target is any truthy value.
    def where(input, property, target_value = nil)
      ary = InputIterator.new(input)
      if ary.empty?
        []
      elsif ary.first.respond_to?(:[]) && target_value.nil?
        begin
          ary.select { |item| item[property] }
        rescue TypeError
          raise_property_error(property)
        end
      elsif ary.first.respond_to?(:[])
        begin
          ary.select { |item| item[property] == target_value }
        rescue TypeError
          raise_property_error(property)
        end
      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)
      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 = InputIterator.new(input)
+      ary = [input].flatten
      ary.reverse
    end
    # map/collect on a given property
    def map(input, property)
-      InputIterator.new(input).map do |e|
+      flatten_if_necessary(input).map do |e|
        e = e.call if e.is_a?(Proc)
        if property == "to_liquid"
          e
        elsif e.respond_to?(:[])
-          r = e[property]
+          e[property]
          r.is_a?(Proc) ? r.call : r
        end
      end
    rescue TypeError
      raise_property_error(property)
    end
    # Remove nils within an array
    # provide optional property with which to check for nil
    def compact(input, property = nil)
      ary = InputIterator.new(input)
      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 = '')
-      input.to_s.gsub(string.to_s, replacement.to_s)
+      input.to_s.gsub(string, replacement.to_s)
    end
    # Replace the first occurrences of a string with another
    def replace_first(input, string, replacement = '')
-      input.to_s.sub(string.to_s, replacement.to_s)
+      input.to_s.sub(string, replacement.to_s)
    end
    # remove a substring
    def remove(input, string)
-      input.to_s.gsub(string.to_s, '')
+      input.to_s.gsub(string, '')
    end
    # remove the first occurrences of a substring
    def remove_first(input, string)
-      input.to_s.sub(string.to_s, '')
+      input.to_s.sub(string, '')
    end
    # add one string to another
@@ -276,13 +146,6 @@ module Liquid
      input.to_s + string.to_s
    end
    def concat(input, array)
      unless array.respond_to?(:to_ary)
        raise ArgumentError, "concat filter requires an array argument"
      end
      InputIterator.new(input).concat(array)
    end
    # prepend a string to another
    def prepend(input, string)
      string.to_s + input.to_s
@@ -293,7 +156,7 @@ module Liquid
      input.to_s.gsub(/\n/, "<br />\n")
    end
-    # Reformat a date using Ruby's core Time#strftime( string ) -> string
+    # Reformat a date
    #
    #   %a - The abbreviated weekday name (``Sun'')
    #   %A - The  full  weekday  name (``Sunday'')
@@ -307,7 +170,6 @@ module Liquid
    #   %m - Month of the year (01..12)
    #   %M - Minute of the hour (00..59)
    #   %p - Meridian indicator (``AM''  or  ``PM'')
    #   %s - Number of seconds since 1970-01-01 00:00:00 UTC.
    #   %S - Second of the minute (00..60)
    #   %U - Week  number  of the current year,
    #           starting with the first Sunday as the first
@@ -322,14 +184,34 @@ module Liquid
    #   %Y - Year with century
    #   %Z - Time zone name
    #   %% - Literal ``%'' character
    #
    #   See also: http://www.ruby-doc.org/core/Time.html#method-i-strftime
    def date(input, format)
      return input if format.to_s.empty?
-      return input unless date = Utils.to_date(input)
+      if format.to_s.empty?
        return input.to_s
      end
-      date.strftime(format.to_s)
+      if ((input.is_a?(String) && !/\A\d+\z/.match(input.to_s).nil?) || input.is_a?(Integer)) && input.to_i > 0
        input = Time.at(input.to_i)
      end
      date = if input.is_a?(String)
        case input.downcase
        when 'now', 'today'
          Time.now
        else
          Time.parse(input)
        end
      else
        input
      end
      if date.respond_to?(:strftime)
        date.strftime(format.to_s)
      else
        input
      end
    rescue
      input
    end
    # Get the first element of the passed in array
@@ -350,12 +232,6 @@ module Liquid
      array.last if array.respond_to?(:last)
    end
    # absolute value
    def abs(input)
      result = Utils.to_number(input).abs
      result.is_a?(BigDecimal) ? result.to_f : result
    end
    # addition
    def plus(input, operand)
      apply_operation(input, operand, :+)
@@ -374,135 +250,47 @@ 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)
+    def default(input, default_value = "")
-      result = Utils.to_number(input).round(Utils.to_number(n))
+      is_blank = input.respond_to?(:empty?) ? input.empty? : !input
-      result = result.to_f if result.is_a?(BigDecimal)
+      is_blank ? default_value : input
      result = result.to_i if n == 0
      result
    rescue ::FloatDomainError => e
      raise Liquid::FloatDomainError, e.message
    end
    def ceil(input)
      Utils.to_number(input).ceil.to_i
    rescue ::FloatDomainError => e
      raise Liquid::FloatDomainError, e.message
    end
    def floor(input)
      Utils.to_number(input).floor.to_i
    rescue ::FloatDomainError => e
      raise Liquid::FloatDomainError, e.message
    end
    def at_least(input, n)
      min_value = Utils.to_number(n)
      result = Utils.to_number(input)
      result = min_value if min_value > result
      result.is_a?(BigDecimal) ? result.to_f : result
    end
    def at_most(input, n)
      max_value = Utils.to_number(n)
      result = Utils.to_number(input)
      result = max_value if max_value < result
      result.is_a?(BigDecimal) ? result.to_f : result
    end
    def default(input, default_value = '')
      if !input || input.respond_to?(:empty?) && input.empty?
        Usage.increment("default_filter_received_false_value") if input == false # See https://github.com/Shopify/liquid/issues/1127
        default_value
      else
        input
      end
    end
    private
-    def raise_property_error(property)
+    def flatten_if_necessary(input)
-      raise Liquid::ArgumentError, "cannot select the property '#{property}'"
+      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)
      case obj
      when Float
        BigDecimal.new(obj.to_s)
      when Numeric
        obj
      when String
        (obj.strip =~ /\A\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
      else
        0
      end
    end
    def apply_operation(input, operand, operation)
-      result = Utils.to_number(input).send(operation, Utils.to_number(operand))
+      result = to_number(input).send(operation, to_number(operand))
      result.is_a?(BigDecimal) ? result.to_f : result
    end
    def nil_safe_compare(a, b)
      if !a.nil? && !b.nil?
        a <=> b
      else
        a.nil? ? 1 : -1
      end
    end
    def nil_safe_casecmp(a, b)
      if !a.nil? && !b.nil?
        a.to_s.casecmp(b.to_s)
      else
        a.nil? ? 1 : -1
      end
    end
    class InputIterator
      include Enumerable
      def initialize(input)
        @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|
          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
        end
      end
    end
  end
  Template.register_filter(StandardFilters)
--- a/lib/liquid/strainer.rb
+++ b/lib/liquid/strainer.rb
@@ -1,21 +1,19 @@
 # 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:
-    @@global_strainer = Class.new(Strainer) do
+    @@filters = []
-      @filter_methods = Set.new
+    @@known_filters = Set.new
-    end
+    @@known_methods = Set.new
    @@strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(@@global_strainer) do
+      hash[filters] = Class.new(Strainer) do
-        @filter_methods = @@global_strainer.filter_methods.dup
+        filters.each { |f| include f }
        filters.each { |f| add_filter(f) }
      end
    end
@@ -23,46 +21,43 @@ module Liquid
      @context = context
    end
-    class << self
+    def self.global_filter(filter)
-      attr_reader :filter_methods
+      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
      add_known_filter(filter)
      @@filters << filter unless @@filters.include?(filter)
    end
-    def self.add_filter(filter)
+    def self.add_known_filter(filter)
-      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
+      unless @@known_filters.include?(filter)
-      unless include?(filter)
+        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
-        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
+        new_methods = filter.instance_methods.map(&:to_s)
-        if invokable_non_public_methods.any?
+        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
-          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
+        @@known_methods.merge(new_methods)
-        else
+        @@known_filters.add(filter)
          send(:include, filter)
          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
        end
      end
    end
-    def self.global_filter(filter)
+    def self.strainer_class_cache
-      @@strainer_class_cache.clear
+      @@strainer_class_cache
      @@global_strainer.add_filter(filter)
    end
    def self.invokable?(method)
      @filter_methods.include?(method.to_s)
    end
    def self.create(context, filters = [])
-      @@strainer_class_cache[filters].new(context)
+      filters = @@filters + filters
      strainer_class_cache[filters].new(context)
    end
    def invoke(method, *args)
-      if self.class.invokable?(method)
+      if invokable?(method)
        send(method, *args)
      elsif @context&.strict_filters
        raise Liquid::UndefinedFilter, "undefined filter #{method}"
      else
        args.first
      end
    rescue ::ArgumentError => e
-      raise Liquid::ArgumentError, e.message, e.backtrace
+      raise Liquid::ArgumentError.new(e.message)
    end
    def invokable?(method)
      @@known_methods.include?(method.to_s) && respond_to?(method)
    end
  end
 end
--- a/lib/liquid/tablerowloop_drop.rb
+++ b/lib/liquid/tablerowloop_drop.rb
@@ -1,64 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class TablerowloopDrop < Drop
    def initialize(length, cols)
      @length = length
      @row = 1
      @col = 1
      @cols = cols
      @index = 0
    end
    attr_reader :length, :col, :row
    def index
      @index + 1
    end
    def index0
      @index
    end
    def col0
      @col - 1
    end
    def rindex
      @length - @index
    end
    def rindex0
      @length - @index - 1
    end
    def first
      @index == 0
    end
    def last
      @index == @length - 1
    end
    def col_first
      @col == 1
    end
    def col_last
      @col == @cols
    end
    protected
    def increment!
      @index += 1
      if @col == @cols
        @col = 1
        @row += 1
      else
        @col += 1
      end
    end
  end
 end
--- a/lib/liquid/tag.rb
+++ b/lib/liquid/tag.rb
@@ -1,53 +1,56 @@
 # frozen_string_literal: true
 module Liquid
  class Tag
-    attr_reader :nodelist, :tag_name, :line_number, :parse_context
+    attr_accessor :options
-    alias_method :options, :parse_context
+    attr_reader :nodelist, :warnings
    include ParserSwitching
-    class << self
+    def self.new_with_options(tag_name, markup, tokens, options)
-      def parse(tag_name, markup, tokenizer, parse_context)
+      # Forgive me Matz for I have sinned. I know this code is weird
-        tag = new(tag_name, markup, parse_context)
+      # but it was necessary to maintain API compatibility.
-        tag.parse(tokenizer)
+      new_tag = self.allocate
-        tag
+      new_tag.options = options
-      end
+      new_tag.send(:initialize, tag_name, markup, tokens)
-
+      new_tag
      private :new
    end
-    def initialize(tag_name, markup, parse_context)
+    def initialize(tag_name, markup, tokens)
      @tag_name   = tag_name
      @markup     = markup
-      @parse_context = parse_context
+      @options    ||= {} # needs || because might be set before initialize
      @line_number = parse_context.line_number
    end
    def parse(_tokens)
    end
    def raw
      "#{@tag_name} #{@markup}"
    end
    def name
      self.class.name.downcase
    end
-    def render(_context)
+    def render(context)
      ''
    end
-    # For backwards compatibility with custom tags. In a future release, the semantics
+    def blank?
-    # of the `render_to_output_buffer` method will become the default and the `render`
+      @blank || false
    # method will be removed.
    def render_to_output_buffer(context, output)
      output << render(context)
      output
    end
-    def blank?
+    def parse_with_selected_parser(markup)
-      false
+      case @options[:error_mode] || Template.error_mode
      when :strict then strict_parse_with_error_context(markup)
      when :lax    then lax_parse(markup)
      when :warn
        begin
          return strict_parse_with_error_context(markup)
        rescue SyntaxError => e
          @warnings ||= []
          @warnings << e
          return lax_parse(markup)
        end
      end
    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 # Tag
 end # Liquid
--- a/lib/liquid/tags/assign.rb
+++ b/lib/liquid/tags/assign.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Assign sets a variable in your template.
  #
  #   {% assign foo = 'monkey' %}
@@ -10,55 +9,29 @@ module Liquid
  #  {{ foo }}
  #
  class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
-    def self.syntax_error_translation_key
+    def initialize(tag_name, markup, tokens)
      "errors.syntax.assign"
    end
    attr_reader :to, :from
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to = $1
-        @from = Variable.new(Regexp.last_match(2), options)
+        @from = Variable.new($2)
      else
-        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign")
      end
      super
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
      val = @from.render(context)
      context.scopes.last[@to] = val
-      context.resource_limits.assign_score += assign_score_of(val)
+      context.increment_used_resources(:assign_score_current, val)
-      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', Assign)
--- a/lib/liquid/tags/break.rb
+++ b/lib/liquid/tags/break.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Break tag to be used to break out of a for loop.
  #
  # == Basic Usage:
@@ -11,9 +10,11 @@ module Liquid
  #    {% endfor %}
  #
  class Break < Tag
    def interrupt
      BreakInterrupt.new
    end
  end
  Template.register_tag('break', Break)
--- a/lib/liquid/tags/capture.rb
+++ b/lib/liquid/tags/capture.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Capture stores the result of a block into a variable without rendering it inplace.
  #
  #   {% capture heading %}
@@ -13,23 +12,23 @@ module Liquid
  # in a sidebar or footer.
  #
  class Capture < Block
-    Syntax = /(#{VariableSignature}+)/o
+    Syntax = /(\w+)/
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
      super
      if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to = $1
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.capture")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
      end
      super
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      previous_output_size = output.bytesize
+      output = super
      super
      context.scopes.last[@to] = output
-      context.resource_limits.assign_score += (output.bytesize - previous_output_size)
+      context.increment_used_resources(:assign_score_current, output)
-      output
+      ''
    end
    def blank?
--- a/lib/liquid/tags/case.rb
+++ b/lib/liquid/tags/case.rb
@@ -1,33 +1,26 @@
 # frozen_string_literal: true
 module Liquid
  class Case < Block
    Syntax     = /(#{QuotedFragment})/o
-    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/o
-    attr_reader :blocks, :left
+    def initialize(tag_name, markup, tokens)
    def initialize(tag_name, markup, options)
      super
      @blocks = []
      if markup =~ Syntax
-        @left = Expression.parse(Regexp.last_match(1))
+        @left = $1
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.case")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case"))
      end
    end
-    def parse(tokens)
+      super
      body = BlockBody.new
      body = @blocks.last.attachment while parse_body(body, tokens)
    end
    def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
    end
    def unknown_tag(tag, markup, tokens)
      @nodelist = []
      case tag
      when 'when'
        record_when_condition(markup)
@@ -38,54 +31,49 @@ module Liquid
      end
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      execute_else_block = true
+      context.stack do
        execute_else_block = true
-      @blocks.each do |block|
+        output = ''
-        if block.else?
+        @blocks.each do |block|
-          block.attachment.render_to_output_buffer(context, output) if execute_else_block
+          if block.else?
-        elsif block.evaluate(context)
+            return render_all(block.attachment, context) if execute_else_block
-          execute_else_block = false
+          elsif block.evaluate(context)
-          block.attachment.render_to_output_buffer(context, output)
+            execute_else_block = false
            output << render_all(block.attachment, context)
          end
        end
        output
      end
      output
    end
    private
    def record_when_condition(markup)
      body = BlockBody.new
      while markup
-        unless markup =~ WhenSyntax
+        # Create a new nodelist and assign it to the new block
-          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when")
+        if not markup =~ WhenSyntax
          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when"))
        end
-        markup = Regexp.last_match(2)
+        markup = $2
-        block = Condition.new(@left, '==', Expression.parse(Regexp.last_match(1)))
+        block = Condition.new(@left, '==', $1)
-        block.attach(body)
+        block.attach(@nodelist)
-        @blocks << block
+        @blocks.push(block)
      end
    end
    def record_else_condition(markup)
-      unless markup.strip.empty?
+      if not markup.strip.empty?
-        raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else"))
      end
      block = ElseCondition.new
-      block.attach(BlockBody.new)
+      block.attach(@nodelist)
      @blocks << block
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [@node.left] + @node.blocks
      end
    end
  end
  Template.register_tag('case', Case)
--- a/lib/liquid/tags/comment.rb
+++ b/lib/liquid/tags/comment.rb
@@ -1,12 +1,10 @@
 # frozen_string_literal: true
 module Liquid
  class Comment < Block
-    def render_to_output_buffer(_context, output)
+    def render(context)
-      output
+      ''
    end
-    def unknown_tag(_tag, _markup, _tokens)
+    def unknown_tag(tag, markup, tokens)
    end
    def blank?
--- a/lib/liquid/tags/continue.rb
+++ b/lib/liquid/tags/continue.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Continue tag to be used to break out of a for loop.
  #
  # == Basic Usage:
@@ -11,9 +10,11 @@ module Liquid
  #    {% endfor %}
  #
  class Continue < Tag
    def interrupt
      ContinueInterrupt.new
    end
  end
  Template.register_tag('continue', Continue)
--- a/lib/liquid/tags/cycle.rb
+++ b/lib/liquid/tags/cycle.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
  #
@@ -15,61 +13,47 @@ module Liquid
  #
  class Cycle < Tag
    SimpleSyntax = /\A#{QuotedFragment}+/o
-    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/o
-    attr_reader :variables
+    def initialize(tag_name, markup, tokens)
    def initialize(tag_name, markup, options)
      super
      case markup
      when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
+        @variables = variables_from_string($2)
-        @name = Expression.parse(Regexp.last_match(1))
+        @name = $1
      when SimpleSyntax
        @variables = variables_from_string(markup)
-        @name = @variables.to_s
+        @name = "'#{@variables.to_s}'"
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle"))
      end
      super
    end
    def render(context)
      context.registers[:cycle] ||= Hash.new(0)
      context.stack do
        key = context[@name]
        iteration = context.registers[:cycle][key]
        result = context[@variables[iteration]]
        iteration += 1
        iteration  = 0  if iteration >= @variables.size
        context.registers[:cycle][key] = iteration
        result
      end
    end
-    def render_to_output_buffer(context, output)
+    def blank?
-      context.registers[:cycle] ||= {}
+      false
      key = context.evaluate(@name)
      iteration = context.registers[:cycle][key].to_i
      val = context.evaluate(@variables[iteration])
      if val.is_a?(Array)
        val = val.join
      elsif !val.is_a?(String)
        val = val.to_s
      end
      output << val
      iteration += 1
      iteration  = 0 if iteration >= @variables.size
      context.registers[:cycle][key] = iteration
      output
    end
    private
    def variables_from_string(markup)
      markup.split(',').collect do |var|
        var =~ /\s*(#{QuotedFragment})\s*/o
-        Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
+        $1 ? $1 : nil
      end.compact
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        Array(@node.variables)
      end
    end
  end
  Template.register_tag('cycle', Cycle)
--- a/lib/liquid/tags/decrement.rb
+++ b/lib/liquid/tags/decrement.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # decrement is used in a place where one needs to insert a counter
  #     into a template, and needs the counter to survive across
  #     multiple instantiations of the template.
@@ -20,18 +19,20 @@ module Liquid
  #    Hello: -3
  #
  class Decrement < Tag
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
      super
      @variable = markup.strip
      super
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
      value = context.environments.first[@variable] ||= 0
-      value -= 1
+      value = value - 1
      context.environments.first[@variable] = value
-      output << value.to_s
+      value.to_s
      output
    end
    private
  end
  Template.register_tag('decrement', Decrement)
--- a/lib/liquid/tags/echo.rb
+++ b/lib/liquid/tags/echo.rb
@@ -1,26 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  # Echo outputs an expression
  #
  #   {% echo monkey %}
  #   {% echo user.name %}
  #
  # This is identical to variable output syntax, like {{ foo }}, but works
  # inside {% liquid %} tags. The full syntax is supported, including filters:
  #
  #   {% echo user | link %}
  #
  class Echo < Tag
    def initialize(tag_name, markup, parse_context)
      super
      @variable = Variable.new(markup, parse_context)
    end
    def render(context)
      @variable.render_to_output_buffer(context, +'')
    end
  end
  Template.register_tag('echo', Echo)
 end
--- a/lib/liquid/tags/for.rb
+++ b/lib/liquid/tags/for.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # "For" iterates over an array or collection.
  # Several useful variables are available to you within the loop.
  #
@@ -25,7 +24,7 @@ module Liquid
  #      {{ item.name }}
  #    {% end %}
  #
-  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
+  #  To reverse the for loop simply use {% for item in collection reversed %}
  #
  # == Available variables:
  #
@@ -43,174 +42,132 @@ module Liquid
  #                   where 0 is the last item.
  # forloop.first:: Returns true if the item is the first item.
  # forloop.last:: Returns true if the item is the last item.
  # forloop.parentloop:: Provides access to the parent loop, if present.
  #
  class For < Block
    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
-    attr_reader :collection_name, :variable_name, :limit, :from
+    def initialize(tag_name, markup, tokens)
    def initialize(tag_name, markup, options)
      super
      @from = @limit = nil
      parse_with_selected_parser(markup)
-      @for_block = BlockBody.new
+      @nodelist = @for_block = []
-      @else_block = nil
+      super
    end
    def parse(tokens)
      return unless parse_body(@for_block, tokens)
      parse_body(@else_block, tokens)
    end
    def nodelist
-      @else_block ? [@for_block, @else_block] : [@for_block]
+      if @else_block
        @for_block + @else_block
      else
        @for_block
      end
    end
    def unknown_tag(tag, markup, tokens)
      return super unless tag == 'else'
-      @else_block = BlockBody.new
+      @nodelist = @else_block = []
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      segment = collection_segment(context)
+      context.registers[:for] ||= Hash.new(0)
-      if segment.empty?
+      collection = context[@collection_name]
-        render_else(context, output)
+      collection = collection.to_a if collection.is_a?(Range)
      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
      return render_else(context) unless iterable?(collection)
      from = if @attributes['offset'] == 'continue'
        context.registers[:for][@name].to_i
      else
-        render_segment(context, output, segment)
+        context[@attributes['offset']].to_i
      end
-      output
+      limit = context[@attributes['limit']]
      to    = limit ? limit.to_i + from : nil
      segment = Utils.slice_collection(collection, from, to)
      return render_else(context) if segment.empty?
      segment.reverse! if @reversed
      result = ''
      length = segment.length
      # Store our progress through the collection for the continue flag
      context.registers[:for][@name] = from + segment.length
      context.stack do
        segment.each_with_index do |item, index|
          context[@variable_name] = item
          context['forloop'] = {
            'name'    => @name,
            'length'  => length,
            'index'   => index + 1,
            'index0'  => index,
            'rindex'  => length - index,
            'rindex0' => length - index - 1,
            'first'   => (index == 0),
          'last'    => (index == length - 1) }
          result << render_all(@for_block, context)
          # Handle any interrupts if they exist.
          if context.has_interrupt?
            interrupt = context.pop_interrupt
            break if interrupt.is_a? BreakInterrupt
            next if interrupt.is_a? ContinueInterrupt
          end
        end
      end
      result
    end
    protected
    def lax_parse(markup)
      if markup =~ Syntax
-        @variable_name = Regexp.last_match(1)
+        @variable_name = $1
-        collection_name = Regexp.last_match(2)
+        @collection_name = $2
-        @reversed = !!Regexp.last_match(3)
+        @name = "#{$1}-#{$2}"
-        @name = "#{@variable_name}-#{collection_name}"
+        @reversed = $3
-        @collection_name = Expression.parse(collection_name)
+        @attributes = {}
        markup.scan(TagAttributes) do |key, value|
-          set_attribute(key, value)
+          @attributes[key] = value
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.for")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for"))
      end
    end
    def strict_parse(markup)
      p = Parser.new(markup)
      @variable_name = p.consume(:id)
-      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in"))  unless p.id?('in')
-      collection_name = p.expression
+      @collection_name = p.expression
-      @name = "#{@variable_name}-#{collection_name}"
+      @name = "#{@variable_name}-#{@collection_name}"
      @collection_name = Expression.parse(collection_name)
      @reversed = p.id?('reversed')
      @attributes = {}
      while p.look(:id) && p.look(:colon, 1)
        unless attribute = p.id?('limit') || p.id?('offset')
-          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute")
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute"))
        end
        p.consume
-        set_attribute(attribute, p.expression)
+        val = p.expression
        @attributes[attribute] = val
      end
      p.consume(:end_of_string)
    end
    private
-    def collection_segment(context)
+      def render_else(context)
-      offsets = context.registers[:for] ||= {}
+        return @else_block ? [render_all(@else_block, context)] : ''
      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)
+      def iterable?(collection)
-      collection = collection.to_a if collection.is_a?(Range)
+        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
      limit_value = context.evaluate(@limit)
      to = if limit_value.nil?
        nil
      else
        Utils.to_integer(limit_value) + from
      end
      segment = Utils.slice_collection(collection, from, to)
      segment.reverse! if @reversed
      offsets[@name] = from + segment.length
      segment
    end
    def render_segment(context, output, segment)
      for_stack = context.registers[:for_stack] ||= []
      length = segment.length
      context.stack do
        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
        for_stack.push(loop_vars)
        begin
          context['forloop'] = loop_vars
          segment.each do |item|
            context[@variable_name] = item
            @for_block.render_to_output_buffer(context, output)
            loop_vars.send(:increment!)
            # Handle any interrupts if they exist.
            next unless context.interrupt?
            interrupt = context.pop_interrupt
            break if interrupt.is_a?(BreakInterrupt)
            next if interrupt.is_a?(ContinueInterrupt)
          end
        ensure
          for_stack.pop
        end
      end
      output
    end
    def set_attribute(key, expr)
      case key
      when 'offset'
        @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', For)
--- a/lib/liquid/tags/if.rb
+++ b/lib/liquid/tags/if.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  # If is the conditional block
  #
@@ -14,23 +12,16 @@ module Liquid
  class If < Block
    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
    ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS = %w(and or).freeze
+    BOOLEAN_OPERATORS = %w(and or)
-    attr_reader :blocks
+    def initialize(tag_name, markup, tokens)
    def initialize(tag_name, markup, options)
      super
      @blocks = []
      push_block('if', markup)
      super
    end
    def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
    end
    def parse(tokens)
      while parse_body(@blocks.last.attachment, tokens)
      end
    end
    def unknown_tag(tag, markup, tokens)
@@ -41,82 +32,74 @@ module Liquid
      end
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
-      @blocks.each do |block|
+      context.stack do
-        if block.evaluate(context)
+        @blocks.each do |block|
-          return block.attachment.render_to_output_buffer(context, output)
+          if block.evaluate(context)
            return render_all(block.attachment, context)
          end
        end
        ''
      end
      output
    end
    private
-    def push_block(tag, markup)
+      def push_block(tag, markup)
-      block = if tag == 'else'
+        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
-      @blocks.push(block)
+      def lax_parse(markup)
-      block.attach(BlockBody.new)
+        expressions = markup.scan(ExpressionsAndOperators).reverse
-    end
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless expressions.shift =~ Syntax
-    def lax_parse(markup)
+        condition = Condition.new($1, $2, $3)
      expressions = markup.scan(ExpressionsAndOperators)
      raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
-      condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+        while not expressions.empty?
          operator = (expressions.shift).to_s.strip
-      until expressions.empty?
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless expressions.shift.to_s =~ Syntax
        operator = expressions.pop.to_s.strip
-        raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop.to_s =~ Syntax
+          new_condition = Condition.new($1, $2, $3)
          raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless BOOLEAN_OPERATORS.include?(operator)
          new_condition.send(operator, condition)
          condition = new_condition
        end
-        new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+        condition
        raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
        new_condition.send(operator, condition)
        condition = new_condition
      end
-      condition
+      def strict_parse(markup)
-    end
+        p = Parser.new(markup)
-    def strict_parse(markup)
+        condition = parse_comparison(p)
      p = Parser.new(markup)
      condition = parse_binary_comparisons(p)
      p.consume(:end_of_string)
      condition
    end
-    def parse_binary_comparisons(p)
+        while op = (p.id?('and') || p.id?('or'))
-      condition = parse_comparison(p)
+          new_cond = parse_comparison(p)
-      first_condition = condition
+          new_cond.send(op, condition)
-      while op = (p.id?('and') || p.id?('or'))
+          condition = new_cond
-        child_condition = parse_comparison(p)
+        end
-        condition.send(op, child_condition)
+        p.consume(:end_of_string)
-        condition = child_condition
+
        condition
      end
      first_condition
    end
-    def parse_comparison(p)
+      def parse_comparison(p)
-      a = Expression.parse(p.expression)
+        a = p.expression
-      if op = p.consume?(:comparison)
+        if op = p.consume?(:comparison)
-        b = Expression.parse(p.expression)
+          b = 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', If)
--- a/lib/liquid/tags/ifchanged.rb
+++ b/lib/liquid/tags/ifchanged.rb
@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 module Liquid
  class Ifchanged < Block
    def render_to_output_buffer(context, output)
      block_output = +''
      super(context, block_output)
-      if block_output != context.registers[:ifchanged]
+    def render(context)
-        context.registers[:ifchanged] = block_output
+      context.stack do
-        output << block_output
+
        output = super
        if output != context.registers[:ifchanged]
          context.registers[:ifchanged] = output
          output
        else
          ''
        end
      end
      output
    end
  end
--- a/lib/liquid/tags/include.rb
+++ b/lib/liquid/tags/include.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Include allows templates to relate with other templates
  #
  # Simply include another template:
@@ -18,89 +17,78 @@ module Liquid
  class Include < Tag
    Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
-    attr_reader :template_name_expr, :variable_name_expr, :attributes
+    def initialize(tag_name, markup, tokens)
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
-        template_name = Regexp.last_match(1)
+        @template_name = $1
-        variable_name = Regexp.last_match(3)
+        @variable_name = $3
-
+        @attributes    = {}
        @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)
+          @attributes[key] = value
        end
      else
-        raise SyntaxError, options[:locale].t("errors.syntax.include")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include"))
      end
    end
    def parse(_tokens)
    end
    def render_to_output_buffer(context, output)
      template_name = context.evaluate(@template_name_expr)
      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
      partial = PartialCache.load(
        template_name,
        context: context,
        parse_context: parse_context
      )
      context_variable_name = template_name.split('/').last
      variable = if @variable_name_expr
        context.evaluate(@variable_name_expr)
      else
        context.find_variable(template_name, raise_on_not_found: false)
      end
-      old_template_name = context.template_name
+      super
-      old_partial = context.partial
+    end
      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)
+    def blank?
-            variable.each do |var|
+      false
-              context[context_variable_name] = var
+    end
-              partial.render_to_output_buffer(context, output)
+
-            end
+    def render(context)
-          else
+      partial = load_cached_partial(context)
-            context[context_variable_name] = variable
+      variable = context[@variable_name || @template_name[1..-2]]
-            partial.render_to_output_buffer(context, output)
+
-          end
+      context.stack do
        @attributes.each do |key, value|
          context[key] = context[value]
        end
      ensure
        context.template_name = old_template_name
        context.partial = old_partial
      end
-      output
+        context_variable_name = @template_name[1..-2].split('/').last
-    end
+        if variable.is_a?(Array)
-
+          variable.collect do |var|
-    alias_method :parse_context, :options
+            context[context_variable_name] = var
-    private :parse_context
+            partial.render(context)
-
+          end
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+        else
-      def children
+          context[context_variable_name] = variable
-        [
+          partial.render(context)
-          @node.template_name_expr,
+        end
          @node.variable_name_expr,
        ] + @node.attributes.values
      end
    end
    private
      def load_cached_partial(context)
        cached_partials = context.registers[:cached_partials] || {}
        template_name = context[@template_name]
        if cached = cached_partials[template_name]
          return cached
        end
        source = read_template_from_file_system(context)
        partial = Liquid::Template.parse(source)
        cached_partials[template_name] = partial
        context.registers[:cached_partials] = cached_partials
        partial
      end
      def read_template_from_file_system(context)
        file_system = context.registers[:file_system] || Liquid::Template.file_system
        # make read_template_file call backwards-compatible.
        case file_system.method(:read_template_file).arity
        when 1
          file_system.read_template_file(context[@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
  Template.register_tag('include', Include)
--- a/lib/liquid/tags/increment.rb
+++ b/lib/liquid/tags/increment.rb
@@ -1,5 +1,3 @@
 # frozen_string_literal: true
 module Liquid
  # increment is used in a place where one needs to insert a counter
  #     into a template, and needs the counter to survive across
@@ -17,17 +15,19 @@ module Liquid
  #    Hello: 2
  #
  class Increment < Tag
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
      super
      @variable = markup.strip
      super
    end
-    def render_to_output_buffer(context, output)
+    def render(context)
      value = context.environments.first[@variable] ||= 0
      context.environments.first[@variable] = value + 1
      value.to_s
    end
-      output << value.to_s
+    def blank?
-      output
+      false
    end
  end
--- a/lib/liquid/tags/raw.rb
+++ b/lib/liquid/tags/raw.rb
@@ -1,47 +1,16 @@
 # frozen_string_literal: true
 module Liquid
  class Raw < Block
-    Syntax = /\A\s*\z/
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/o
    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
-    def initialize(tag_name, markup, parse_context)
+    def parse_body(tokens)
-      super
+      @nodelist ||= []
-
+      @nodelist.clear
      ensure_valid_markup(tag_name, markup, parse_context)
    end
    def parse(tokens)
      @body = +''
      while token = tokens.shift
        if token =~ FullTokenPossiblyInvalid
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
+          @nodelist << $1 if $1 != ""
-          return if block_delimiter == Regexp.last_match(2)
+          return if block_delimiter == $2
        end
-        @body << token unless token.empty?
+        @nodelist << token if not 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 markup =~ Syntax
        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args", tag: tag_name)
      end
    end
  end
--- a/lib/liquid/tags/render.rb
+++ b/lib/liquid/tags/render.rb
@@ -1,56 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class Render < Tag
    SYNTAX = /(#{QuotedString})#{QuotedFragment}*/o
    attr_reader :template_name_expr, :attributes
    def initialize(tag_name, markup, options)
      super
      raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
      template_name = Regexp.last_match(1)
      @template_name_expr = Expression.parse(template_name)
      @attributes = {}
      markup.scan(TagAttributes) do |key, value|
        @attributes[key] = Expression.parse(value)
      end
    end
    def render_to_output_buffer(context, output)
      # Though we evaluate this here we will only ever parse it as a string literal.
      template_name = context.evaluate(@template_name_expr)
      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
      partial = PartialCache.load(
        template_name,
        context: context,
        parse_context: parse_context
      )
      inner_context = context.new_isolated_subcontext
      inner_context.template_name = template_name
      inner_context.partial = true
      @attributes.each do |key, value|
        inner_context[key] = context.evaluate(value)
      end
      partial.render_to_output_buffer(inner_context, output)
      output
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        [
          @node.template_name_expr,
        ] + @node.attributes.values
      end
    end
  end
  Template.register_tag('render', Render)
 end
--- a/lib/liquid/tags/table_row.rb
+++ b/lib/liquid/tags/table_row.rb
@@ -1,67 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class TableRow < Block
    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
    attr_reader :variable_name, :collection_name, :attributes
    def initialize(tag_name, markup, options)
      super
      if markup =~ Syntax
        @variable_name = Regexp.last_match(1)
        @collection_name = Expression.parse(Regexp.last_match(2))
        @attributes = {}
        markup.scan(TagAttributes) do |key, value|
          @attributes[key] = Expression.parse(value)
        end
      else
        raise SyntaxError, options[:locale].t("errors.syntax.table_row")
      end
    end
    def render_to_output_buffer(context, output)
      (collection = context.evaluate(@collection_name)) || (return '')
      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
      to = @attributes.key?('limit') ? from + context.evaluate(@attributes['limit']).to_i : nil
      collection = Utils.slice_collection(collection, from, to)
      length = collection.length
      cols = context.evaluate(@attributes['cols']).to_i
      output << "<tr class=\"row1\">\n"
      context.stack do
        tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
        context['tablerowloop'] = tablerowloop
        collection.each do |item|
          context[@variable_name] = item
          output << "<td class=\"col#{tablerowloop.col}\">"
          super
          output << '</td>'
          if tablerowloop.col_last && !tablerowloop.last
            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
          end
          tablerowloop.send(:increment!)
        end
      end
      output << "</tr>\n"
      output
    end
    class ParseTreeVisitor < Liquid::ParseTreeVisitor
      def children
        super + @node.attributes.values + [@node.collection_name]
      end
    end
  end
  Template.register_tag('tablerow', TableRow)
 end
--- a/lib/liquid/tags/unless.rb
+++ b/lib/liquid/tags/unless.rb
@@ -1,30 +1,33 @@
-# frozen_string_literal: true
+require File.dirname(__FILE__) + '/if'
 require_relative 'if'
 module Liquid
  # Unless is a conditional just like 'if' but works on the inverse logic.
  #
-  #   {% unless x < 0 %} x is greater than zero {% endunless %}
+  #   {% unless x < 0 %} x is greater than zero {% end %}
  #
  class Unless < If
-    def render_to_output_buffer(context, output)
+    def render(context)
-      # First condition is interpreted backwards ( if not )
+      context.stack do
      first_block = @blocks.first
      unless first_block.evaluate(context)
        return first_block.attachment.render_to_output_buffer(context, output)
      end
-      # After the first condition unless works just like if
+        # First condition is interpreted backwards ( if not )
-      @blocks[1..-1].each do |block|
+        first_block = @blocks.first
-        if block.evaluate(context)
+        unless first_block.evaluate(context)
-          return block.attachment.render_to_output_buffer(context, output)
+          return render_all(first_block.attachment, context)
        end
      end
-      output
+        # 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
        ''
      end
    end
  end
  Template.register_tag('unless', Unless)
 end
--- a/lib/liquid/template.rb
+++ b/lib/liquid/template.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Templates are central to liquid.
  # Interpretating templates is a two step process. First you compile the
  # source code you got. During compile time some extensive error checking is performed.
@@ -15,67 +14,14 @@ module Liquid
  #   template.render('user_name' => 'bob')
  #
  class Template
-    attr_accessor :root
+    DEFAULT_OPTIONS = {
-    attr_reader :resource_limits, :warnings
+      :locale => I18n.new
    }
    attr_accessor :root, :resource_limits
    @@file_system = BlankFileSystem.new
    class TagRegistry
      include Enumerable
      def initialize
        @tags = {}
        @cache = {}
      end
      def [](tag_name)
        return nil unless @tags.key?(tag_name)
        return @cache[tag_name] if Liquid.cache_classes
        lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
      end
      def []=(tag_name, klass)
        @tags[tag_name]  = klass.name
        @cache[tag_name] = klass
      end
      def delete(tag_name)
        @tags.delete(tag_name)
        @cache.delete(tag_name)
      end
      def each(&block)
        @tags.each(&block)
      end
      private
      def lookup_class(name)
        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.
      # :warn is the default and will give deprecation warnings when invalid syntax is used.
      # :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
@@ -89,15 +35,19 @@ module Liquid
      end
      def tags
-        @tags ||= TagRegistry.new
+        @tags ||= {}
      end
      # Sets how strict the parser should be.
      # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
      # :warn is the default and will give deprecation warnings when invalid syntax is used.
      # :strict will enforce correct syntax.
      def error_mode=(mode)
        @error_mode = mode
      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
@@ -106,36 +56,32 @@ 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)
        template
      end
    end
    # creates a new <tt>Template</tt> from an array of tokens. Use <tt>Template.parse</tt> instead
    def initialize
-      @rethrow_errors = false
+      @resource_limits = {}
      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
    end
    # Parse source code.
    # Returns self for easy chaining
    def parse(source, options = {})
-      @options = options
+      @root = Document.new(tokenize(source), DEFAULT_OPTIONS.merge(options))
-      @profiling = options[:profile]
+      @warnings = nil
      @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
@@ -157,9 +103,6 @@ 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
@@ -171,13 +114,7 @@ module Liquid
      context = case args.first
      when Liquid::Context
-        c = args.shift
+        args.shift
        if @rethrow_errors
          c.exception_renderer = ->(_e) { raise }
        end
        c
      when Liquid::Drop
        drop = args.shift
        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
@@ -189,29 +126,29 @@ module Liquid
        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
      end
      output = nil
      case args.last
      when Hash
        options = args.pop
        output = options[:output] if options[:output]
-        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
+        if options[:registers].is_a?(Hash)
          self.registers.merge!(options[:registers])
        end
-        apply_options_to_context(context, options)
+        if options[:filters]
-      when Module, Array
+          context.add_filters(options[:filters])
        end
      when Module
        context.add_filters(args.pop)
      when Array
        context.add_filters(args.pop)
      end
      # Retrying a render resets resource usage
      context.resource_limits.reset
      begin
        # render the nodelist.
        # for performance reasons we get an array back here. join will make a string out of it.
-        with_profiling(context) do
+        result = @root.render(context)
-          @root.render_to_output_buffer(context, output || +'')
+        result.respond_to?(:join) ? result.join : result
        end
      rescue Liquid::MemoryError => e
        context.handle_error(e)
      ensure
@@ -220,43 +157,15 @@ module Liquid
    end
    def render!(*args)
-      @rethrow_errors = true
+      @rethrow_errors = true; render(*args)
      render(*args)
    end
    def render_to_output_buffer(context, output)
      render(context, output: output)
    end
    private
    def tokenize(source)
-      Tokenizer.new(source, @line_numbers)
+      source = source.source if source.respond_to?(:source)
      Tokenizer.new(source.to_s)
    end
    def with_profiling(context)
      if @profiling && !context.partial
        raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
        @profiler = Profiler.new
        @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
--- a/lib/liquid/tokenizer.rb
+++ b/lib/liquid/tokenizer.rb
@@ -1,39 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  class Tokenizer
    attr_reader :line_number, :for_liquid_tag
    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
      @source = source
      @line_number = line_number || (line_numbers ? 1 : nil)
      @for_liquid_tag = for_liquid_tag
      @tokens = tokenize
    end
    def shift
      (token = @tokens.shift) || return
      if @line_number
        @line_number += @for_liquid_tag ? 1 : token.count("\n")
      end
      token
    end
    private
    def tokenize
      return [] if @source.to_s.empty?
      return @source.split("\n") if @for_liquid_tag
      tokens = @source.split(TemplateParser)
      # removes the rogue empty element at the beginning of the array
      tokens.shift if tokens[0]&.empty?
      tokens
    end
  end
 end
--- a/lib/liquid/usage.rb
+++ b/lib/liquid/usage.rb
@@ -1,8 +0,0 @@
 # frozen_string_literal: true
 module Liquid
  module Usage
    def self.increment(name)
    end
  end
 end
--- a/lib/liquid/utils.rb
+++ b/lib/liquid/utils.rb
@@ -1,26 +1,27 @@
 # frozen_string_literal: true
 module Liquid
  module Utils
    def self.slice_collection(collection, from, to)
-      if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
+      if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
        collection.load_slice(from, to)
      else
        slice_collection_using_each(collection, from, to)
      end
    end
    def self.non_blank_string?(collection)
      collection.is_a?(String) && collection != ''
    end
    def self.slice_collection_using_each(collection, from, to)
      segments = []
      index = 0
      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      if collection.is_a?(String)
+      return [collection] if non_blank_string?(collection)
        return collection.empty? ? [] : [collection]
      end
      return [] unless collection.respond_to?(:each)
      collection.each do |item|
        if to && to <= index
          break
        end
@@ -34,52 +35,5 @@ module Liquid
      segments
    end
    def self.to_integer(num)
      return num if num.is_a?(Integer)
      num = num.to_s
      begin
        Integer(num)
      rescue ::ArgumentError
        raise Liquid::ArgumentError, "invalid integer"
      end
    end
    def self.to_number(obj)
      case obj
      when Float
        BigDecimal(obj.to_s)
      when Numeric
        obj
      when String
        obj.strip =~ /\A-?\d+\.\d+\z/ ? BigDecimal(obj) : obj.to_i
      else
        if obj.respond_to?(:to_number)
          obj.to_number
        else
          0
        end
      end
    end
    def self.to_date(obj)
      return obj if obj.respond_to?(:strftime)
      if obj.is_a?(String)
        return nil if obj.empty?
        obj = obj.downcase
      end
      case obj
      when 'now', 'today'
        Time.now
      when /\A\d+\z/, Integer
        Time.at(obj.to_i)
      when String
        Time.parse(obj)
      end
    rescue ::ArgumentError
      nil
    end
  end
 end
--- a/lib/liquid/variable.rb
+++ b/lib/liquid/variable.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module Liquid
  # Holds variables. Variables are only loaded "just in time"
  # and are not evaluated as part of the render stage
  #
@@ -12,150 +11,98 @@ module Liquid
  #   {{ user | link }}
  #
  class Variable
-    FilterMarkupRegex = /#{FilterSeparator}\s*(.*)/om
+    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
-    FilterArgsRegex = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
+    attr_accessor :filters, :name, :warnings
    JustTagAttributes = /\A#{TagAttributes}\z/o
    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
-    attr_accessor :filters, :name, :line_number
+    def initialize(markup, options = {})
    attr_reader :parse_context
    alias_method :options, :parse_context
    include ParserSwitching
    def initialize(markup, parse_context)
      @markup  = markup
      @name    = nil
-      @parse_context = parse_context
+      @options = options || {}
      @line_number = parse_context.line_number
      parse_with_selected_parser(markup)
    end
-    def raw
+      case @options[:error_mode] || Template.error_mode
-      @markup
+      when :strict then strict_parse(markup)
-    end
+      when :lax    then lax_parse(markup)
-
+      when :warn
-    def markup_context(markup)
+        begin
-      "in \"{{#{markup}}}\""
+          strict_parse(markup)
        rescue SyntaxError => e
          @warnings ||= []
          @warnings << e
          lax_parse(markup)
        end
      end
    end
    def lax_parse(markup)
      @filters = []
-      return unless markup =~ MarkupWithQuotedFragment
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/o)
-
+        @name = match[1]
-      name_markup = Regexp.last_match(1)
+        if match[2].match(/#{FilterSeparator}\s*(.*)/o)
-      filter_markup = Regexp.last_match(2)
+          filters = Regexp.last_match(1).scan(FilterParser)
-      @name = Expression.parse(name_markup)
+          filters.each do |f|
-      if filter_markup =~ FilterMarkupRegex
+            if matches = f.match(/\s*(\w+)/)
-        filters = Regexp.last_match(1).scan(FilterParser)
+              filtername = matches[1]
-        filters.each do |f|
+              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-          next unless f =~ /\w+/
+              @filters << [filtername, filterargs]
-          filtername = Regexp.last_match(0)
+            end
-          filterargs = f.scan(FilterArgsRegex).flatten
+          end
          @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 = Expression.parse(p.expression)
+      @name = p.look(:pipe) ? '' : p.expression
      while p.consume?(:pipe)
        filtername = p.consume(:id)
        filterargs = p.consume?(:colon) ? parse_filterargs(p) : []
-        @filters << parse_filter_expressions(filtername, filterargs)
+        @filters << [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
-      filterargs << p.argument while p.consume?(:comma)
+      while p.consume?(:comma)
        filterargs << p.argument
      end
      filterargs
    end
    def render(context)
-      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
+      return '' if @name.nil?
-        filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
+      @filters.inject(context[@name]) do |output, filter|
-        context.invoke(filter_name, output, *filter_args)
+        filterargs = []
-      end
+        keyword_args = {}
-
+        filter[1].to_a.each do |a|
-      obj = context.apply_global_filter(obj)
+          if matches = a.match(/\A#{TagAttributes}\z/o)
-      taint_check(context, obj)
+            keyword_args[matches[1]] = context[matches[2]]
-      obj
+          else
-    end
+            filterargs << context[a]
-
+          end
    def render_to_output_buffer(context, output)
      obj = render(context)
      if obj.is_a?(Array)
        output << obj.join
      elsif obj.nil?
      else
        output << obj.to_s
      end
      output
    end
    private
    def parse_filter_expressions(filter_name, unparsed_args)
      filter_args = []
      keyword_args = nil
      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
-      end
+        filterargs << keyword_args unless keyword_args.empty?
-      result = [filter_name, filter_args]
+        begin
-      result << keyword_args if keyword_args
+          output = context.invoke(filter[0], output, *filterargs)
-      result
+        rescue FilterNotFound
-    end
+          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
    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
--- a/lib/liquid/variable_lookup.rb
+++ b/lib/liquid/variable_lookup.rb
@@ -1,90 +0,0 @@
 # 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
--- a/lib/liquid/version.rb
+++ b/lib/liquid/version.rb
@@ -1,6 +1,4 @@
 # encoding: utf-8
 # frozen_string_literal: true
 module Liquid
-  VERSION = "4.0.3"
+  VERSION = "3.0.0"
 end
--- a/liquid.gemspec
+++ b/liquid.gemspec
@@ -1,8 +1,6 @@
 # encoding: utf-8
 # frozen_string_literal: true
 lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$:.unshift lib unless $:.include?(lib)
 require "liquid/version"
@@ -11,22 +9,24 @@ Gem::Specification.new do |s|
  s.version     = Liquid::VERSION
  s.platform    = Gem::Platform::RUBY
  s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
-  s.authors     = ["Tobias Lütke"]
+  s.authors     = ["Tobias Luetke"]
  s.email       = ["tobi@leetsoft.com"]
  s.homepage    = "http://www.liquidmarkup.org"
  s.license     = "MIT"
-  # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
+  #s.description = "A secure, non-evaling end user template engine with aesthetic markup."
  s.required_ruby_version     = ">= 2.4.0"
  s.required_rubygems_version = ">= 1.3.7"
  s.test_files  = Dir.glob("{test}/**/*")
-  s.files       = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
+  s.files       = Dir.glob("{lib,ext}/**/*") + %w(MIT-LICENSE README.md)
  s.extensions  = ['ext/liquid/extconf.rb']
-  s.extra_rdoc_files = ["History.md", "README.md"]
+  s.extra_rdoc_files  = ["History.md", "README.md"]
  s.require_path = "lib"
-  s.add_development_dependency('rake', '~> 11.3')
+  s.add_development_dependency 'rake-compiler'
-  s.add_development_dependency('minitest')
+  s.add_development_dependency 'stackprof'
  s.add_development_dependency 'rake'
  s.add_development_dependency 'activesupport'
 end
--- a/performance/benchmark.rb
+++ b/performance/benchmark.rb
@@ -1,20 +1,12 @@
-# frozen_string_literal: true
+require 'rubygems'
-
+require 'benchmark'
-require 'benchmark/ips'
+require File.dirname(__FILE__) + '/theme_runner'
 require_relative 'theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
-Benchmark.ips do |x|
+Benchmark.bmbm do |x|
-  x.time = 10
+  x.report("parse:")   { 100.times { profiler.compile } }
-  x.warmup = 5
+  x.report("parse & run:")   { 100.times { profiler.run } }
  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
--- a/performance/memory_profile.rb
+++ b/performance/memory_profile.rb
@@ -1,63 +0,0 @@
 # frozen_string_literal: true
 require 'benchmark/ips'
 require 'memory_profiler'
 require 'terminal-table'
 require_relative 'theme_runner'
 class Profiler
  LOG_LABEL   = "Profiling: ".rjust(14).freeze
  REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
  def self.run
    puts
    yield new
  end
  def initialize
    @allocated = []
    @retained  = []
    @headings  = []
  end
  def profile(phase, &block)
    print LOG_LABEL
    print "#{phase}.. ".ljust(10)
    report = MemoryProfiler.report(&block)
    puts 'Done.'
    @headings  << phase.capitalize
    @allocated << "#{report.scale_bytes(report.total_allocated_memsize)} (#{report.total_allocated} objects)"
    @retained  << "#{report.scale_bytes(report.total_retained_memsize)} (#{report.total_retained} objects)"
    return if ENV['CI']
    require 'fileutils'
    report_file = File.join(REPORTS_DIR, "#{sanitize(phase)}.txt")
    FileUtils.mkdir_p(REPORTS_DIR)
    report.pretty_print(to_file: report_file, scale_bytes: true)
  end
  def tabulate
    table = Terminal::Table.new(headings: @headings.unshift('Phase')) do |t|
      t << @allocated.unshift('Total allocated')
      t << @retained.unshift('Total retained')
    end
    puts
    puts table
    puts "\nDetailed report(s) saved to #{REPORTS_DIR}/" unless ENV['CI']
  end
  def sanitize(string)
    string.downcase.gsub(/[\W]/, '-').squeeze('-')
  end
 end
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 runner = ThemeRunner.new
 Profiler.run do |x|
  x.profile('parse') { runner.compile }
  x.profile('render') { runner.render }
  x.tabulate
 end
--- a/performance/profile.rb
+++ b/performance/profile.rb
@@ -1,26 +1,19 @@
-# frozen_string_literal: true
+require 'rubygems'
 require 'ruby-prof' rescue fail("install ruby-prof extension/gem")
 require File.dirname(__FILE__) + '/theme_runner'
 require 'stackprof'
 require_relative 'theme_runner'
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run
-[:cpu, :object].each do |profile_type|
+puts 'Running profiler...'
  puts "Profiling in #{profile_type} mode..."
  results = StackProf.run(mode: profile_type) do
    200.times do
      profiler.run
    end
  end
-  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
+results  = profiler.run_profile
    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)
+puts 'Success'
-  File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
+puts
 [RubyProf::FlatPrinter, RubyProf::GraphHtmlPrinter, RubyProf::CallTreePrinter, RubyProf::DotPrinter].each do |klass|
  filename = (ENV['TMP'] || '/tmp') + (klass.name.include?('Html') ? "/liquid.#{klass.name.downcase}.html" : "/callgrind.liquid.#{klass.name.downcase}.txt")
  filename.gsub!(/:+/, '_')
  File.open(filename, "w+") { |fp| klass.new(results).print(fp, :print_file => true, :min_percent => 3) }
  $stderr.puts "wrote #{klass.name} output to #{filename}"
 end
--- a/performance/shopify/comment_form.rb
+++ b/performance/shopify/comment_form.rb
@@ -1,20 +1,18 @@
 # frozen_string_literal: true
 class CommentForm < Liquid::Block
  Syntax = /(#{Liquid::VariableSignature}+)/
-  def initialize(tag_name, markup, options)
+  def initialize(tag_name, markup, tokens)
    super
    if markup =~ Syntax
-      @variable_name = Regexp.last_match(1)
+      @variable_name = $1
      @attributes = {}
    else
-      raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]"
+      raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
    end
    super
  end
-  def render_to_output_buffer(context, output)
+  def render(context)
    article = context[@variable_name]
    context.stack do
@@ -22,16 +20,14 @@ class CommentForm < Liquid::Block
        'posted_successfully?' => context.registers[:posted_successfully],
        'errors' => context['comment.errors'],
        'author' => context['comment.author'],
-        'email' => context['comment.email'],
+        'email'  => context['comment.email'],
-        'body' => context['comment.body'],
+        'body'   => context['comment.body']
      }
-
+      wrap_in_form(article, render_all(@nodelist, context))
      output << wrap_in_form(article, render_all(@nodelist, context, output))
      output
    end
  end
  def wrap_in_form(article, input)
-    %(<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>)
+    %Q{<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>}
  end
 end
--- a/performance/shopify/database.rb
+++ b/performance/shopify/database.rb
@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 require 'yaml'
 module Database
  # Load the standard vision toolkit database and re-arrage it to be simply exportable
  # to liquid as assigns. All this is based on Shopify
  def self.tables
    @tables ||= begin
-      db = YAML.load_file("#{__dir__}/vision.database.yml")
+      db = YAML.load_file(File.dirname(__FILE__) + '/vision.database.yml')
      # From vision source
      db['products'].each do |product|
@@ -18,10 +16,9 @@ module Database
      end
      # key the tables by handles, as this is how liquid expects it.
-      db = db.each_with_object({}) do |(key, values), assigns|
+      db = db.inject({}) do |assigns, (key, values)|
-        assigns[key] = values.each_with_object({}) do |v, h|
+        assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; }
-          h[v['handle']] = v
+        assigns
        end
      end
      # Some standard direct accessors so that the specialized templates
@@ -33,8 +30,8 @@ module Database
      db['cart']       = {
        'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
-        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
+        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
-        'items' => db['line_items'].values,
+        'items'       => db['line_items'].values
      }
      db
@@ -42,7 +39,7 @@ module Database
  end
 end
-if __FILE__ == $PROGRAM_NAME
+if __FILE__ == $0
-  p(Database.tables['collections']['frontpage'].keys)
+  p Database.tables['collections']['frontpage'].keys
-  # p Database.tables['blog']['articles']
+  #p Database.tables['blog']['articles']
 end
--- a/performance/shopify/json_filter.rb
+++ b/performance/shopify/json_filter.rb
@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 require 'json'
 module JsonFilter
  def json(object)
-    JSON.dump(object.reject { |k, _v| k == "collections" })
+    object.reject {|k,v| k == "collections" }.to_json
  end
 end
--- a/performance/shopify/liquid.rb
+++ b/performance/shopify/liquid.rb
@@ -1,21 +1,19 @@
-# frozen_string_literal: true
+$:.unshift File.dirname(__FILE__) + '/../../lib'
 require File.dirname(__FILE__) + '/../../lib/liquid'
-$LOAD_PATH.unshift(__dir__ + '/../../lib')
+require File.dirname(__FILE__) + '/comment_form'
-require_relative '../../lib/liquid'
+require File.dirname(__FILE__) + '/paginate'
 require File.dirname(__FILE__) + '/json_filter'
 require File.dirname(__FILE__) + '/money_filter'
 require File.dirname(__FILE__) + '/shop_filter'
 require File.dirname(__FILE__) + '/tag_filter'
 require File.dirname(__FILE__) + '/weight_filter'
-require_relative 'comment_form'
+Liquid::Template.register_tag 'paginate', Paginate
-require_relative 'paginate'
+Liquid::Template.register_tag 'form', CommentForm
 require_relative 'json_filter'
 require_relative 'money_filter'
 require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'
-Liquid::Template.register_tag('paginate', Paginate)
+Liquid::Template.register_filter JsonFilter
-Liquid::Template.register_tag('form', CommentForm)
+Liquid::Template.register_filter MoneyFilter
-
+Liquid::Template.register_filter WeightFilter
-Liquid::Template.register_filter(JsonFilter)
+Liquid::Template.register_filter ShopFilter
-Liquid::Template.register_filter(MoneyFilter)
+Liquid::Template.register_filter TagFilter
 Liquid::Template.register_filter(WeightFilter)
 Liquid::Template.register_filter(ShopFilter)
 Liquid::Template.register_filter(TagFilter)
--- a/performance/shopify/money_filter.rb
+++ b/performance/shopify/money_filter.rb
@@ -1,14 +1,13 @@
 # frozen_string_literal: true
 module MoneyFilter
  def money_with_currency(money)
    return '' if money.nil?
-    format("$ %.2f USD", money / 100.0)
+    sprintf("$ %.2f USD", money/100.0)
  end
  def money(money)
    return '' if money.nil?
-    format("$ %.2f", money / 100.0)
+    sprintf("$ %.2f", money/100.0)
  end
  private
--- a/performance/shopify/paginate.rb
+++ b/performance/shopify/paginate.rb
@@ -1,15 +1,13 @@
 # frozen_string_literal: true
 class Paginate < Liquid::Block
-  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
-  def initialize(tag_name, markup, options)
+  def initialize(tag_name, markup, tokens)
-    super
+    @nodelist = []
    if markup =~ Syntax
-      @collection_name = Regexp.last_match(1)
+      @collection_name = $1
-      @page_size = if Regexp.last_match(2)
+      @page_size = if $2
-        Regexp.last_match(3).to_i
+        $3.to_i
      else
        20
      end
@@ -19,47 +17,50 @@ class Paginate < Liquid::Block
        @attributes[key] = value
      end
    else
-      raise SyntaxError, "Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number"
+      raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
    end
    super
  end
-  def render_to_output_buffer(context, output)
+  def render(context)
    @context = context
    context.stack do
-      current_page = context['current_page'].to_i
+      current_page  = context['current_page'].to_i
      pagination = {
-        'page_size' => @page_size,
+        '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, "Cannot paginate array '#{@collection_name}'. Not found." if collection_size.nil?
+      raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection_size.nil?
      page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1
      pagination['items']      = collection_size
-      pagination['pages']      = page_count - 1
+      pagination['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'] || page >= current_page + @attributes['window_size']
+          elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
            next if hellip_break
            pagination['parts'] << no_link('&hellip;')
            hellip_break = true
@@ -72,18 +73,18 @@ class Paginate < Liquid::Block
        end
      end
-      super
+      render_all(@nodelist, context)
    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
--- a/performance/shopify/shop_filter.rb
+++ b/performance/shopify/shop_filter.rb
@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 module ShopFilter
  def asset_url(input)
    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
  end
@@ -17,16 +16,16 @@ module ShopFilter
    %(<script src="#{url}" type="text/javascript"></script>)
  end
-  def stylesheet_tag(url, media = "all")
+  def stylesheet_tag(url, media="all")
    %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
  end
-  def link_to(link, url, title = "")
+  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)
@@ -46,15 +45,16 @@ module ShopFilter
  end
  def url_for_vendor(vendor_title)
-    "/collections/#{to_handle(vendor_title)}"
+    "/collections/#{vendor_title.to_handle}"
  end
  def url_for_type(type_title)
-    "/collections/#{to_handle(type_title)}"
+    "/collections/#{type_title.to_handle}"
  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,24 +62,27 @@ module ShopFilter
    when 'original'
      return '/files/shops/random_number/' + url
    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
+      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"
    else
      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
    end
  end
  def default_pagination(paginate)
    html = []
    html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
-    paginate['parts'].each do |part|
+    for part in paginate['parts']
-      html << if part['is_link']
+
-        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+      if part['is_link']
        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
      elsif part['title'].to_i == paginate['current_page'].to_i
-        %(<span class="page current">#{part['title']}</span>)
+        html << %(<span class="page current">#{part['title']}</span>)
      else
-        %(<span class="deco">#{part['title']}</span>)
+        html << %(<span class="deco">#{part['title']}</span>)
      end
    end
    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
@@ -92,15 +95,4 @@ module ShopFilter
    input == 1 ? singular : plural
  end
  private
  def to_handle(str)
    result = str.dup
    result.downcase!
    result.delete!("'\"()[]")
    result.gsub!(/\W+/, '-')
    result.gsub!(/-+\z/, '') if result[-1] == '-'
    result.gsub!(/\A-+/, '') if result[0] == '-'
    result
  end
 end
--- a/performance/shopify/tag_filter.rb
+++ b/performance/shopify/tag_filter.rb
@@ -1,11 +1,10 @@
 # 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
@@ -15,11 +14,12 @@ module TagFilter
  def link_to_add_tag(label, tag)
    tags = (@context['current_tags'] + [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
  end
  def link_to_remove_tag(label, tag)
    tags = (@context['current_tags'] - [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
  end
 end
--- a/performance/shopify/weight_filter.rb
+++ b/performance/shopify/weight_filter.rb
@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 module WeightFilter
  def weight(grams)
-    format("%.2f", grams / 1000)
+    sprintf("%.2f", grams / 1000)
  end
  def weight_with_unit(grams)
    "#{weight(grams)} kg"
  end
 end
--- a/performance/stackprof.rb
+++ b/performance/stackprof.rb
@@ -0,0 +1,15 @@
 require 'stackprof' rescue fail("install stackprof extension/gem")
 require File.dirname(__FILE__) + '/theme_runner'
 profiler = ThemeRunner.new
 profiler.run
 results = StackProf.run(mode: :cpu, out: ENV['FILENAME']) do
  100.times do
    profiler.run
  end
 end
 if results.kind_of?(File)
  puts "wrote stackprof dump to #{results.path}"
 else
  StackProf::Report.new(results).print_text(false, 20)
 end
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Dylan Thacker-Smith	bb954bce1e	Use StringSlice.join on the rendered results.	2014-02-28 14:12:57 -05:00
Dylan Thacker-Smith	cc0276bb97	Add a StringSlice class to use in the nodelist.	2014-02-28 13:16:07 -05:00
Dylan Thacker-Smith	03d586aafe	Add convenience methods for getting a struct from a ruby object. If we are trying to get the struct from something other than self, then we should make sure to check the class of the object. This util functions make this easier.	2014-02-28 10:08:55 -05:00
Dylan Thacker-Smith	dc8a34a52f	Implement Block#parse_body in C.	2014-02-28 07:47:36 -05:00
Dylan Thacker-Smith	99cebf74bc	Rename Block#parse to parse_body since that is how it is being used.	2014-02-27 23:16:11 -05:00
Dylan Thacker-Smith	7eb64886dc	Move the parse method out of Tag, only blocks need the body parsed. The parse method should be renamed to something like parse_body, since that is how it is used, and no non-block tags were using the parse method.	2014-02-27 22:31:09 -05:00
Dylan Thacker-Smith	f89046e81f	Use super rather than render_all in single block render classes.	2014-02-27 21:38:49 -05:00
Dylan Thacker-Smith	9ee4573ef4	Avoid keeping track of two lists of nodes during parsing.	2014-02-27 20:51:05 -05:00
Dylan Thacker-Smith	a48b4f47f6	Return nil in Document#block_delimiter rather than an empty array. The block delimiter is normally a string, so nil makes more sense when there is no delimiter. We also don't want to allocate an array for no reason.	2014-02-27 20:06:57 -05:00
Dylan Thacker-Smith	72d402837e	Remove unused Block#end_tag method. Although the method is called, it is defined with an empty body and not overridden to do anything else.	2014-02-27 18:53:18 -05:00
Dylan Thacker-Smith	06bef40527	Fix a missing return warning.	2014-02-27 18:47:55 -05:00
Dylan Thacker-Smith	a48b245e6e	Turn on C compiler warnings.	2014-02-27 18:45:57 -05:00
Dylan Thacker-Smith	d4aabda625	Avoid freeing of uninitialized memory. Thanks to Isha for pointing this out.	2014-02-27 18:32:19 -05:00
Dylan Thacker-Smith	dab6bdfdee	Make sure the ext directory is included in the distributed gem.	2014-02-27 15:50:43 -05:00
Dylan Thacker-Smith	8c075fca1f	Remove a couple FIXME comments which are only partially a lie. I added those comments before creating an invalid token type to return the error. However, we still aren't making use of the token type.	2014-02-27 15:21:57 -05:00
Dylan Thacker-Smith	ea8406e36e	Create a Liquid::Tokenizer class in the C extension.	2014-02-27 15:20:22 -05:00
Dylan Thacker-Smith	8bb3bca64a	Require the liquid extension when liquid is required.	2014-02-27 14:22:18 -05:00
Dylan Thacker-Smith	5de1082201	Add profile:stackprof rake task.	2014-02-27 11:20:49 -05:00
Dylan Thacker-Smith	7ba02d2811	Use start and end of string rather than line matching in regexes.	2014-02-27 10:07:04 -05:00
Dylan Thacker-Smith	2066676bf4	Add a C extension that doesn't yet do anything.	2014-02-27 09:58:33 -05:00
`@@ -3,4 +3,4 @@`
	`<p>It is {{date}}</p>`	`<p>It is {{date}}</p>`


	`<p>Check out the <a href="/products">Products</a> screen </p>`	`<p>Check out the <a href="http://localhost:3000/products">Products</a> screen </p>`