Use StringSlice.join on the rendered results.

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.

.gitignore

@@ -5,5 +5,6 @@ pkg
 *.rbc
 .rvmrc
 .ruby-version
+*.bundle
+/tmp
 Gemfile.lock
-.bundle

.rubocop.yml

@@ -1,125 +0,0 @@
-inherit_from: ./.rubocop_todo.yml
-
-AllCops:
-  Exclude:
-    - 'performance/shopify/*'
-    - 'pkg/**'
-
-Metrics/BlockNesting:
-  Max: 3
-  Exclude:
-    - 'lib/liquid/block_body.rb'
-
-Metrics/ModuleLength:
-  Enabled: false
-
-Metrics/ClassLength:
-  Enabled: false
-
-Lint/AssignmentInCondition:
-  Enabled: false
-
-Lint/AmbiguousOperator:
-  Enabled: false
-
-Lint/AmbiguousRegexpLiteral:
-  Enabled: false
-
-Lint/ParenthesesAsGroupedExpression:
-  Enabled: false
-
-Lint/UnusedBlockArgument:
-  Enabled: false
-
-Lint/EndAlignment:
-  AlignWith: variable
-
-Lint/UnusedMethodArgument:
-  Enabled: false
-
-Style/SingleLineBlockParams:
-  Enabled: false
-
-Style/DoubleNegation:
-  Enabled: false
-
-Style/StringLiteralsInInterpolation:
-  Enabled: false
-
-Style/AndOr:
-  Enabled: false
-
-Style/SignalException:
-  Enabled: false
-
-Style/StringLiterals:
-  Enabled: false
-
-Style/BracesAroundHashParameters:
-  Enabled: false
-
-Style/NumericLiterals:
-  Enabled: false
-
-Style/SpaceInsideBrackets:
-  Enabled: false
-
-Style/SpaceBeforeBlockBraces:
-  Enabled: false
-
-Style/Documentation:
-  Enabled: false
-
-Style/ClassAndModuleChildren:
-  Enabled: false
-
-Style/TrailingComma:
-  Enabled: false
-
-Style/IndentHash:
-  EnforcedStyle: consistent
-
-Style/FormatString:
-  Enabled: false
-
-Style/AlignParameters:
-  EnforcedStyle: with_fixed_indentation
-
-Style/MultilineOperationIndentation:
-  EnforcedStyle: indented
-
-Style/IfUnlessModifier:
-  Enabled: false
-
-Style/RaiseArgs:
-  Enabled: false
-
-Style/DeprecatedHashMethods:
-  Enabled: false
-
-Style/RegexpLiteral:
-  Enabled: false
-
-Style/SymbolLiteral:
-  Enabled: false
-
-Performance/Count:
-  Enabled: false
-
-Style/ConstantName:
-  Enabled: false
-
-Style/CaseIndentation:
-  Enabled: false
-
-Style/ClassVars:
-  Enabled: false
-
-Style/PerlBackrefs:
-  Enabled: false
-
-Style/TrivialAccessors:
-  AllowPredicates: true
-
-Style/WordArray:
-  Enabled: false

.rubocop_todo.yml

@@ -1,72 +0,0 @@
-# This configuration was generated by `rubocop --auto-gen-config`
-# on 2015-06-08 18:16:16 +0000 using RuboCop version 0.32.0.
-# The point is for the user to remove these configuration records
-# one by one as the offenses are removed from the code base.
-# Note that changes in the inspected code, or installation of new
-# versions of RuboCop, may require this file to be generated again.
-
-# Offense count: 5
-Lint/NestedMethodDefinition:
-  Enabled: false
-
-# Offense count: 53
-Metrics/AbcSize:
-  Max: 58
-
-# Offense count: 12
-Metrics/CyclomaticComplexity:
-  Max: 15
-
-# Offense count: 553
-# Configuration parameters: AllowURI, URISchemes.
-Metrics/LineLength:
-  Max: 294
-
-# Offense count: 77
-# Configuration parameters: CountComments.
-Metrics/MethodLength:
-  Max: 46
-
-# Offense count: 6
-Metrics/PerceivedComplexity:
-  Max: 13
-
-# Offense count: 1
-Style/AccessorMethodName:
-  Enabled: false
-
-# Offense count: 1
-# Cop supports --auto-correct.
-Style/ClosingParenthesisIndentation:
-  Enabled: false
-
-# Offense count: 3
-# Configuration parameters: MinBodyLength.
-Style/GuardClause:
-  Enabled: false
-
-# Offense count: 4
-# Configuration parameters: EnforcedStyle, SupportedStyles.
-Style/MethodName:
-  Enabled: false
-
-# Offense count: 1
-Style/MultilineBlockChain:
-  Enabled: false
-
-# Offense count: 2
-# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
-Style/Next:
-  Enabled: false
-
-# Offense count: 7
-# Cop supports --auto-correct.
-# Configuration parameters: AllowAsExpressionSeparator.
-Style/Semicolon:
-  Enabled: false
-
-# Offense count: 1
-# Cop supports --auto-correct.
-# Configuration parameters: MaxLineLength.
-Style/WhileUntilModifier:
-  Enabled: false

.travis.yml

@@ -1,29 +1,16 @@
-language: ruby
-
 rvm:
-  - 2.1
+  - 1.9.3
-  - 2.2
+  - 2.0.0
-  - 2.3.3
+  - 2.1.0
-  - ruby-head
+  - jruby-19mode
   - jruby-head
-#  - rbx-2
+  - rbx-19mode
-
-sudo: false
-
-addons:
-  apt:
-    packages:
-    - libgmp3-dev
-
 matrix:
   allow_failures:
+    - rvm: rbx-19mode
     - rvm: jruby-head
 
-install:
+script: "rake test"
-  - gem install rainbow -v 2.2.1
-  - bundle install
-
-script: "bundle exec rake"
 
 notifications:
   disable: true

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.
 

Gemfile

@@ -1,17 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-gem 'stackprof', platforms: :mri_21
-
-group :benchmark, :test do
-  gem 'benchmark-ips'
-end
-
-group :test do
-  gem 'spy', '0.4.1'
-  gem 'rubocop', '0.34.2'
-
-  platform :mri do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'bd53db95de3d44d631e7c5a267c3d934e66107dd'
-  end
-end

History.md

@@ -1,155 +1,59 @@
-# Liquid Change Log
+# Liquid Version History
 
-## 4.0.0 / 2016-12-14 / branch "4-0-stable"
+## 3.0.0 / not yet released / branch "master"
 
-### Changed
+* ...
-* Render an opaque internal error by default for non-Liquid::Error (#835) [Dylan Thacker-Smith]
+* Add a to_s default for liquid drops, see #306 [Adam Doeler, releod]
-* Ruby 2.0 support dropped (#832) [Dylan Thacker-Smith]
+* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
-* Add to_number Drop method to allow custom drops to work with number filters (#731)
+* Make if, for & case tags return complete and consistent nodelists, see #250 [Nick Jones, dntj]
-* Add strict_variables and strict_filters options to detect undefined references (#691)
+* Prevent arbitrary method invocation on condition objects, see #274 [Dylan Thacker-Smith, dylanahsmith]
-* Improve loop performance (#681) [Florian Weingarten]
+* Don't call to_sym when creating conditions for security reasons, see #273 [Bouke van der Bijl, bouk]
-* Rename Drop method `before_method` to `liquid_method_missing` (#661) [Thierry Joyal]
+* Fix resource counting bug with respond_to?(:length), see #263 [Florian Weingarten, fw42]
-* Add url_decode filter to invert url_encode (#645) [Larry Archer]
+* Allow specifying custom patterns for template filenames, see #284 [Andrei Gladkyi, agladkyi]
-* Add global_filter to apply a filter to all output (#610) [Loren Hale]
+* Allow drops to optimize loading a slice of elements, see #282 [Tom Burns, boourns]
-* Add compact filter (#600) [Carson Reinke]
+* Support for passing variables to snippets in subdirs, see #271 [Joost Hietbrink, joost]
-* Rename deprecated "has_key?" and "has_interrupt?" methods (#593) [Florian Weingarten]
+* Add a class cache to avoid runtime extend calls, see #249 [James Tucker, raggi]
-* Include template name with line numbers in render errors (574) [Dylan Thacker-Smith]
+* Remove some legacy Ruby 1.8 compatibility code, see #276 [Florian Weingarten, fw42]
-* Add sort_natural filter (#554) [Martin Hanzel]
+* Add default filter to standard filters, see #267 [Derrick Reimer, djreimer]
-* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li]
+* Add optional strict parsing and warn parsing, see #235 [Tristan Hume, trishume]
-* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith]
+* Add I18n syntax error translation, see #241 [Simon Hørup Eskildsen, Sirupsen]
-* Add concat filter to concatenate arrays (#429) [Diogo Beato]
+* Make sort filter work on enumerable drops, see #239 [Florian Weingarten, fw42]
-* Ruby 1.9 support dropped (#491) [Justin Li]
+* Fix clashing method names in enumerable drops, see #238 [Florian Weingarten, fw42]
-* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith]
+* Make map filter work on enumerable drops, see #233 [Florian Weingarten, fw42]
-* Remove `liquid_methods` (See https://github.com/Shopify/liquid/pull/568 for replacement)
+* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
-* Liquid::Template.register_filter raises when the module overrides registered public methods as private or protected (#705) [Gaurav Chande]
+* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
 
-### Fixed
+## 2.6.0 / 2013-11-25 / branch "2.6-stable"
-
-* 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
 
@@ -157,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
 

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)
@@ -73,34 +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
-```

Rakefile

@@ -1,14 +1,15 @@
 require 'rake'
 require 'rake/testtask'
+require 'rake/extensiontask'
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"
 
-task default: [:rubocop, :test]
+task :default => 'test'
 
 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
 
@@ -18,43 +19,25 @@ task :warn_test do
   Rake::Task['base_test'].invoke
 end
 
-task :rubocop do
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new
-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'
-    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"
@@ -62,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"
@@ -73,16 +57,23 @@ 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
 
 desc "Run example"
@@ -90,6 +81,7 @@ 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

circle.yml

@@ -1,3 +0,0 @@
-machine:
-  ruby:
-    version: ruby-2.1

example/server/example_servlet.rb

@@ -17,12 +17,13 @@ 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
@@ -33,12 +34,8 @@ class Servlet < LiquidServlet
     {'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
   end
 
-  def more_products_list
-    [{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-     { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
-  end
-
   def description
     "List of Products ~ This is a list of products with price and description."
   end
+
 end

example/server/liquid_servlet.rb

@@ -1,4 +1,5 @@
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
+
   def do_GET(req, res)
     handle(:get, req, res)
   end
@@ -10,8 +11,7 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   private
 
   def handle(type, req, res)
-    @request = req
+    @request, @response = req, res
-    @response = res
 
     @request.path_info =~ /(\w+)\z/
     @action = $1 || 'index'
@@ -19,10 +19,10 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
 
     @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

example/server/server.rb

@@ -1,12 +1,14 @@
 require 'webrick'
 require 'rexml/document'
 
-require_relative '../../lib/liquid'
+DIR = File.expand_path(File.dirname(__FILE__))
-require_relative 'liquid_servlet'
+
-require_relative 'example_servlet'
+require DIR + '/../../lib/liquid'
+require DIR + '/liquid_servlet'
+require DIR + '/example_servlet'
 
 # Setup webrick
-server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
+server = WEBrick::HTTPServer.new( :Port => ARGV[1] || 3000 )
 server.mount('/', Servlet)
 trap("INT"){ server.shutdown }
 server.start

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>

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 }}

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);
+}

ext/liquid/block.h

@@ -0,0 +1,8 @@
+#ifndef LIQUID_BLOCK_H
+#define LIQUID_BLOCK_H
+
+void init_liquid_block();
+
+extern VALUE cLiquidBlock;
+
+#endif

ext/liquid/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+$CFLAGS << ' -Wall'
+create_makefile("liquid/liquid")

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();
+}

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

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);
+}

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

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");
+}

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

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);
+}

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

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)

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

lib/liquid.rb

@@ -21,59 +21,49 @@
 
 module Liquid
   FilterSeparator             = /\|/
-  ArgumentSeparator           = ','.freeze
+  ArgumentSeparator           = ','
-  FilterArgumentSeparator     = ':'.freeze
+  FilterArgumentSeparator     = ':'
-  VariableAttributeSeparator  = '.'.freeze
+  VariableAttributeSeparator  = '.'
-  WhitespaceControl           = '-'.freeze
   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/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'
 
 # 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 }

lib/liquid/block.rb

@@ -1,67 +1,101 @@
 module Liquid
   class Block < Tag
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
       super
-      @blank = true
+      parse_body(tokens)
-    end
-
-    def parse(tokens)
-      @body = BlockBody.new
-      while parse_body(@body, tokens)
-      end
-    end
-
-    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
+      all_warnings = []
+      all_warnings.concat(@warnings) if @warnings
+
+      (nodelist || []).each do |node|
+        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
       end
 
-    def unknown_tag(tag, _params, _tokens)
+      all_warnings
+    end
+
+    def unknown_tag(tag, params, tokens)
       case tag
-      when 'else'.freeze
+      when 'else'
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze,
+        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else", 
-          block_name: block_name))
+                                                 :block_name => block_name))
-      when 'end'.freeze
+      when 'end'
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
+        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter", 
-          block_name: block_name,
+                                                 :block_name => block_name, 
-          block_delimiter: block_delimiter))
+                                                 :block_delimiter => block_delimiter))
       else
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
+        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)
-      body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
+      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination", :token => token, :tag_end => VariableEnd.inspect))
-        @blank &&= body.blank?
-
-        return false if end_tag_name == block_delimiter
-        unless end_tag_name
-          raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
     end
 
-        # this tag is not registered with the system
+    def unterminated_tag(token)
-        # pass it to the current block for special handling or error reporting
+      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination", :token => token, :tag_end => TagEnd.inspect))
-        unknown_tag(end_tag_name, end_tag_params, tokens)
     end
 
-      true
+    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
+
+          token_output = (token.respond_to?(:render) ? token.render(context) : token)
+          context.increment_used_resources(:render_length_current, token_output)
+          if context.resource_limits_reached?
+            context.resource_limits[:reached] = true
+            raise MemoryError.new("Memory limits exceeded")
+          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
+      end
+
+      StringSlice.join(output)
     end
   end
 end

lib/liquid/block_body.rb

@@ -1,140 +0,0 @@
-module Liquid
-  class BlockBody
-    FullToken = /\A#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
-    ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
-    TAGSTART = "{%".freeze
-    VARSTART = "{{".freeze
-
-    attr_reader :nodelist
-
-    def initialize
-      @nodelist = []
-      @blank = true
-    end
-
-    def parse(tokenizer, parse_context)
-      parse_context.line_number = tokenizer.line_number
-      while token = tokenizer.shift
-        unless token.empty?
-          case
-          when token.start_with?(TAGSTART)
-            whitespace_handler(token, parse_context)
-            if token =~ FullToken
-              tag_name = $1
-              markup = $2
-              # fetch the tag from registered blocks
-              if tag = registered_tags[tag_name]
-                new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-                @blank &&= new_tag.blank?
-                @nodelist << new_tag
-              else
-                # end parsing if we reach an unknown tag and let the caller decide
-                # determine how to proceed
-                return yield tag_name, markup
-              end
-            else
-              raise_missing_tag_terminator(token, parse_context)
-            end
-          when token.start_with?(VARSTART)
-            whitespace_handler(token, parse_context)
-            @nodelist << create_variable(token, parse_context)
-            @blank = false
-          else
-            if parse_context.trim_whitespace
-              token.lstrip!
-            end
-            parse_context.trim_whitespace = false
-            @nodelist << token
-            @blank &&= !!(token =~ /\A\s*\z/)
-          end
-        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)
-      output = []
-      context.resource_limits.render_score += @nodelist.length
-
-      @nodelist.each do |token|
-        # Break out if we have any unhanded interrupts.
-        break if context.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) || token.is_a?(Break)
-            context.push_interrupt(token.interrupt)
-            break
-          end
-
-          node_output = render_node(token, context)
-
-          unless token.is_a?(Block) && token.blank?
-            output << node_output
-          end
-        rescue MemoryError => e
-          raise e
-        rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
-          context.handle_error(e, token.line_number)
-          output << nil
-        rescue ::StandardError => e
-          line_number = token.is_a?(String) ? nil : token.line_number
-          output << context.handle_error(e, line_number)
-        end
-      end
-
-      output.join
-    end
-
-    private
-
-    def render_node(node, context)
-      node_output = node.is_a?(String) ? node : node.render(context)
-      node_output = node_output.is_a?(Array) ? node_output.join : node_output.to_s
-
-      context.resource_limits.render_length += node_output.length
-      if context.resource_limits.reached?
-        raise MemoryError.new("Memory limits exceeded".freeze)
-      end
-      node_output
-    end
-
-    def create_variable(token, parse_context)
-      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.new(parse_context.locale.t("errors.syntax.tag_termination".freeze, token: token, tag_end: TagEnd.inspect))
-    end
-
-    def raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError.new(parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect))
-    end
-
-    def registered_tags
-      Template.tags
-    end
-  end
-end

lib/liquid/condition.rb

@@ -3,27 +3,19 @@ module Liquid
   #
   # Example:
   #
-  #   c = Condition.new(1, '==', 1)
+  #   c = Condition.new('1', '==', '1')
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
-    @@depth = 0
     @@operators = {
-      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '==' => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '!=' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>' => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<'.freeze  => :<,
+      '<'  => :<,
-      '>'.freeze  => :>,
+      '>'  => :>,
-      '>='.freeze => :>=,
+      '>=' => :>=,
-      '<='.freeze => :<=,
+      '<=' => :<=,
-      'contains'.freeze => 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
@@ -34,9 +26,7 @@ module Liquid
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left = left
+      @left, @operator, @right = left, operator, right
-      @operator = operator
-      @right = right
       @child_relation  = nil
       @child_condition = nil
     end
@@ -48,11 +38,6 @@ module Liquid
       when :or
         result || @child_condition.evaluate(context)
       when :and
-        @@depth += 1
-        if @@depth >= 500
-          @@depth = 0
-          raise StackLevelError, "Nesting too deep".freeze
-        end
         result && @child_condition.evaluate(context)
       else
         result
@@ -60,13 +45,11 @@ module Liquid
     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)
@@ -78,23 +61,23 @@ module Liquid
     end
 
     def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
     end
 
     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
@@ -107,32 +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.new("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)
-        rescue ::ArgumentError => e
+      else
-          raise Liquid::ArgumentError.new(e.message)
+        nil
-        end
       end
     end
   end
 
+
   class ElseCondition < Condition
     def else?
       true
     end
 
-    def evaluate(_context)
+    def evaluate(context)
       true
     end
   end
+
 end

lib/liquid/context.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Context keeps the variable stack and resolves variables, as well as keywords
   #
   #   context['variable'] = 'testing'
@@ -13,32 +14,32 @@ module Liquid
   #   context['bob']  #=> nil  class Context
   class Context
     attr_reader :scopes, :errors, :registers, :environments, :resource_limits
-    attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = {})
       @environments    = [environments].flatten
       @scopes          = [(outer_scope || {})]
       @registers       = registers
       @errors          = []
-      @partial          = false
+      @rethrow_errors  = rethrow_errors
-      @strict_variables = false
+      @resource_limits = (resource_limits || {}).merge!({ :render_score_current => 0, :assign_score_current => 0 })
-      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
       squash_instance_assigns_with_environments
 
-      @this_stack_used = false
-
-      self.exception_renderer = Template.default_exception_renderer
-      if rethrow_errors
-        self.exception_renderer = ->(e) { raise }
-      end
-
       @interrupts = []
       @filters = []
-      @global_filter = nil
     end
 
-    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
@@ -51,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)
+        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.
@@ -74,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={})
       @scopes.unshift(new_scope)
-      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
+      raise StackLevelError, "Nesting too deep" if @scopes.length > 100
     end
 
     # Merge a hash of variables in the current local scope
@@ -111,19 +125,11 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope = nil)
+    def stack(new_scope={})
-      old_stack_used = @this_stack_used
-      if new_scope
       push(new_scope)
-        @this_stack_used = true
-      else
-        @this_stack_used = false
-      end
-
       yield
     ensure
-      pop if @this_stack_used
+      pop
-      @this_stack_used = old_stack_used
     end
 
     def clear_instance_assigns
@@ -132,13 +138,26 @@ module Liquid
 
     # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
     def []=(key, value)
-      unless @this_stack_used
-        @this_stack_used = true
-        push({})
-      end
       @scopes[0][key] = value
     end
 
+    def [](key)
+      resolve(key)
+    end
+
+    def has_key?(key)
+      resolve(key) != nil
+    end
+
+    private
+      LITERALS = {
+        nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
+        'true'  => true,
+        'false' => false,
+        'blank' => :blank?,
+        'empty' => :empty?
+      }
+
       # Look up variable, either resolve directly after considering the name. We can directly handle
       # Strings, digits, floats and booleans (true,false).
       # If no match is made we lookup the variable in the current scope and
@@ -147,31 +166,35 @@ module Liquid
       #
       # Example:
       #   products == empty #=> products.empty?
-    def [](expression)
+      def resolve(key)
-      evaluate(Expression.parse(expression))
+        if LITERALS.key?(key)
+          LITERALS[key]
+        else
+          case key
+          when /\A'(.*)'\z/ # Single quoted strings
+            $1
+          when /\A"(.*)"\z/ # Double quoted strings
+            $1
+          when /\A(-?\d+)\z/ # Integer and floats
+            $1.to_i
+          when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+            (resolve($1).to_i..resolve($2).to_i)
+          when /\A(-?\d[\d\.]+)\z/ # Floats
+            $1.to_f
+          else
+            variable(key)
           end
-
-    def key?(key)
-      self[key] != nil
         end
-
-    def evaluate(object)
-      object.respond_to?(:evaluate) ? object.evaluate(self) : object
       end
 
       # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key, raise_on_not_found: true)
+      def find_variable(key)
-      # This was changed from find() to find_index() because this is a very hot
+        scope = @scopes.find { |s| s.has_key?(key) }
-      # path and find_index() is optimized in MRI to reduce object allocation
-      index = @scopes.find_index { |s| s.key?(key) }
-      scope = @scopes[index] if index
-
         variable = nil
 
         if scope.nil?
           @environments.each do |e|
-          variable = lookup_and_evaluate(e, key, raise_on_not_found: raise_on_not_found)
+            if variable = lookup_and_evaluate(e, key)
-          unless variable.nil?
               scope = e
               break
             end
@@ -179,41 +202,78 @@ module Liquid
         end
 
         scope     ||= @environments.last || @scopes.last
-      variable ||= lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
+        variable  ||= lookup_and_evaluate(scope, key)
 
         variable = variable.to_liquid
         variable.context = self if variable.respond_to?(:context=)
 
-      variable
+        return variable
       end
 
-    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
+      # Resolves namespaced queries gracefully.
-      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
+      #
-        raise Liquid::UndefinedVariable, "undefined variable #{key}"
+      # 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
 
-      value = obj[key]
+        if object = find_variable(first_part)
 
-      if value.is_a?(Proc) && obj.respond_to?(:[]=)
+          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
+      end # lookup_and_evaluate
-
-    private
-
-    def internal_error
-      # raise and catch to set backtrace and cause on exception
-      raise Liquid::InternalError, 'internal'
-    rescue Liquid::InternalError => exc
-      exc
-    end
 
       def squash_instance_assigns_with_environments
         @scopes.last.each_key do |k|
           @environments.each do |env|
-          if env.key?(k)
+            if env.has_key?(k)
               scopes.last[k] = lookup_and_evaluate(env, k)
               break
             end
@@ -221,4 +281,5 @@ module Liquid
         end
       end # squash_instance_assigns_with_environments
   end # Context
+
 end # Liquid

lib/liquid/document.rb

@@ -1,27 +1,18 @@
 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'.freeze, 'end'.freeze
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag))
-      else
-        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
-      end
     end
   end
 end

lib/liquid/drop.rb

@@ -1,6 +1,7 @@
 require 'set'
 
 module Liquid
+
   # A drop in liquid is a class which allows you to export DOM like things to liquid.
   # Methods of drops are callable.
   # The main use for liquid drops is to implement lazy loaded objects.
@@ -18,27 +19,28 @@ module Liquid
   #   tmpl = Liquid::Template.parse( ' {% for product in product.top_sales %} {{ product.name }} {%endfor%} '  )
   #   tmpl.render('product' => ProductDrop.new ) # will invoke top_sales query.
   #
-  # Your drop can either implement the methods sans any parameters
+  # 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 && @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
 
@@ -54,25 +56,22 @@ module Liquid
       self.class.name
     end
 
-    alias_method :[], :invoke_drop
+    alias :[] :invoke_drop
+
+    private
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      invokable_methods.include?(method_name.to_s)
+      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
+      end
+      @invokable_methods.include?(method_name.to_s)
     end
   end
 end

lib/liquid/errors.rb

@@ -1,56 +1,12 @@
 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 = ""
-      if is_a?(SyntaxError)
-        str << "Liquid syntax error"
-      else
-        str << "Liquid error"
-      end
-
-      if line_number
-        str << " ("
-        str << template_name << " " if template_name
-        str << "line " << line_number.to_s << ")"
-      end
-
-      str << ": "
-      str
-    end
-  end
-
-  ArgumentError = Class.new(Error)
-  ContextError = Class.new(Error)
-  FileSystemError = Class.new(Error)
-  StandardError = Class.new(Error)
-  SyntaxError = Class.new(Error)
-  StackLevelError = Class.new(Error)
-  TaintedError = Class.new(Error)
-  MemoryError = Class.new(Error)
-  ZeroDivisionError = Class.new(Error)
-  FloatDomainError = Class.new(Error)
-  UndefinedVariable = Class.new(Error)
-  UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter = Class.new(Error)
-  MethodOverrideError = Class.new(Error)
-  InternalError = Class.new(Error)
 end

lib/liquid/expression.rb

@@ -1,45 +0,0 @@
-module Liquid
-  class Expression
-    class MethodLiteral
-      attr_reader :method_name, :to_s
-
-      def initialize(method_name, to_s)
-        @method_name = method_name
-        @to_s = to_s
-      end
-
-      def to_liquid
-        to_s
-      end
-    end
-
-    LITERALS = {
-      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true'.freeze  => true,
-      'false'.freeze => false,
-      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
-      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
-    }
-
-    def self.parse(markup)
-      if LITERALS.key?(markup)
-        LITERALS[markup]
-      else
-        case markup
-        when /\A'(.*)'\z/m # Single quoted strings
-          $1
-        when /\A"(.*)"\z/m # Double quoted strings
-          $1
-        when /\A(-?\d+)\z/ # Integer and floats
-          $1.to_i
-        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
-          RangeLookup.parse($1, $2)
-        when /\A(-?\d[\d\.]+)\z/ # Floats
-          $1.to_f
-        else
-          VariableLookup.parse(markup)
-        end
-      end
-    end
-  end
-end

lib/liquid/extensions.rb

@@ -25,12 +25,6 @@ class Numeric # :nodoc:
   end
 end
 
-class Range # :nodoc:
-  def to_liquid
-    self
-  end
-end
-
 class Time  # :nodoc:
   def to_liquid
     self

lib/liquid/file_system.rb

@@ -14,7 +14,7 @@ module Liquid
   # This will parse the template with a LocalFileSystem implementation rooted at 'template_path'.
   class BlankFileSystem
     # Called by Liquid to retrieve a template file
-    def read_template_file(_template_path)
+    def read_template_file(template_path, context)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -44,14 +44,14 @@ module Liquid
   class LocalFileSystem
     attr_accessor :root
 
-    def initialize(root, pattern = "_%s.liquid".freeze)
+    def initialize(root, pattern = "_%s.liquid")
       @root = root
       @pattern = pattern
     end
 
-    def read_template_file(template_path)
+    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
@@ -59,13 +59,13 @@ module Liquid
     def full_path(template_path)
       raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
 
-      full_path = if template_path.include?('/'.freeze)
+      full_path = if template_path.include?('/')
         File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
       else
         File.join(root, @pattern % template_path)
       end
 
-      raise FileSystemError, "Illegal template path '#{File.expand_path(full_path)}'" unless File.expand_path(full_path).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

lib/liquid/forloop_drop.rb

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

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

lib/liquid/i18n.rb

@@ -2,9 +2,10 @@ require 'yaml'
 
 module Liquid
   class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
+    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
 
-    TranslationError = Class.new(StandardError)
+    class TranslationError < StandardError
+    end
     
     attr_reader :path
 
@@ -22,16 +23,15 @@ 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[$1.to_sym]}"
-      end
+      }
     end
 
     def deep_fetch_translation(name)
-      name.split('.'.freeze).reduce(locale) do |level, cur|
+      name.split('.').reduce(locale) do |level, cur|
         level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
       end
     end

lib/liquid/interrupts.rb

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

lib/liquid/lexer.rb

@@ -2,34 +2,31 @@ require "strscan"
 module Liquid
   class Lexer
     SPECIALS = {
-      '|'.freeze => :pipe,
+      '|' => :pipe,
-      '.'.freeze => :dot,
+      '.' => :dot,
-      ':'.freeze => :colon,
+      ':' => :colon,
-      ','.freeze => :comma,
+      ',' => :comma,
-      '['.freeze => :open_square,
+      '[' => :open_square,
-      ']'.freeze => :close_square,
+      ']' => :close_square,
-      '('.freeze => :open_round,
+      '(' => :open_round,
-      ')'.freeze => :close_round,
+      ')' => :close_round
-      '?'.freeze => :question,
-      '-'.freeze => :dash
     }
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
+    IDENTIFIER = /[\w\-?!]+/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
     NUMBER_LITERAL = /-?\d+(\.\d+)?/
     DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
 
     def initialize(input)
-      @ss = StringScanner.new(input)
+      @ss = StringScanner.new(input.rstrip)
     end
 
     def tokenize
       @output = []
 
-      until @ss.eos?
+      while !@ss.eos?
         @ss.skip(/\s*/)
-        break if @ss.eos?
         tok = case
         when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
         when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]

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]"
@@ -15,12 +14,9 @@
       include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
       unknown_tag: "Unknown tag '%{tag}'"
       invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
-      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"
-    argument:
-      include: "Argument error in tag 'include' - Illegal template name"

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

lib/liquid/parse_context.rb

@@ -1,37 +0,0 @@
-module Liquid
-  class ParseContext
-    attr_accessor :locale, :line_number, :trim_whitespace
-    attr_reader :partial, :warnings, :error_mode
-
-    def initialize(options = {})
-      @template_options = options ? options.dup : {}
-      @locale = @template_options[:locale] ||= I18n.new
-      @warnings = []
-      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

lib/liquid/parser.rb

@@ -66,16 +66,15 @@ module Liquid
       str = ""
       # might be a keyword argument (identifier: expression)
       if look(:id) && look(:colon, 1)
-        str << consume << consume << ' '.freeze
+        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)

lib/liquid/parser_switching.rb

@@ -1,31 +0,0 @@
-module Liquid
-  module ParserSwitching
-    def parse_with_selected_parser(markup)
-      case parse_context.error_mode
-      when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
-      when :warn
-        begin
-          return strict_parse_with_error_context(markup)
-        rescue SyntaxError => e
-          parse_context.warnings << e
-          return lax_parse(markup)
-        end
-      end
-    end
-
-    private
-
-    def strict_parse_with_error_context(markup)
-      strict_parse(markup)
-    rescue SyntaxError => e
-      e.line_number = line_number
-      e.markup_context = markup_context(markup)
-      raise e
-    end
-
-    def markup_context(markup)
-      "in \"#{markup.strip}\""
-    end
-  end
-end

lib/liquid/profiler.rb

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

lib/liquid/profiler/hooks.rb

@@ -1,23 +0,0 @@
-module Liquid
-  class BlockBody
-    def render_node_with_profiling(node, context)
-      Profiler.profile_node_render(node) do
-        render_node_without_profiling(node, context)
-      end
-    end
-
-    alias_method :render_node_without_profiling, :render_node
-    alias_method :render_node, :render_node_with_profiling
-  end
-
-  class Include < Tag
-    def render_with_profiling(context)
-      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_without_profiling(context)
-      end
-    end
-
-    alias_method :render_without_profiling, :render
-    alias_method :render, :render_with_profiling
-  end
-end

lib/liquid/range_lookup.rb

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

lib/liquid/resource_limits.rb

@@ -1,23 +0,0 @@
-module Liquid
-  class ResourceLimits
-    attr_accessor :render_length, :render_score, :assign_score,
-      :render_length_limit, :render_score_limit, :assign_score_limit
-
-    def initialize(limits)
-      @render_length_limit = limits[:render_length_limit]
-      @render_score_limit = limits[:render_score_limit]
-      @assign_score_limit = limits[:assign_score_limit]
-      reset
-    end
-
-    def reached?
-      (@render_length_limit && @render_length > @render_length_limit) ||
-        (@render_score_limit && @render_score > @render_score_limit) ||
-        (@assign_score_limit && @assign_score > @assign_score_limit)
-    end
-
-    def reset
-      @render_length = @render_score = @assign_score = 0
-    end
-  end
-end

lib/liquid/standardfilters.rb

@@ -2,18 +2,14 @@ require 'cgi'
 require 'bigdecimal'
 
 module Liquid
+
   module StandardFilters
-    HTML_ESCAPE = {
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#39;' }
-      '&'.freeze => '&amp;'.freeze,
-      '>'.freeze => '&gt;'.freeze,
-      '<'.freeze => '&lt;'.freeze,
-      '"'.freeze => '&quot;'.freeze,
-      "'".freeze => '&#39;'.freeze
-    }
     HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
 
     # Return the size of an array or of an string
     def size(input)
+
       input.respond_to?(:size) ? input.size : 0
     end
 
@@ -33,51 +29,29 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input).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) unless input.nil?
-    end
-
-    def url_decode(input)
-      CGI.unescape(input) unless input.nil?
-    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 = "...".freeze)
+    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] + truncate_string_str : input_str
+      input.length > length.to_i ? input[0...l] + truncate_string : input
     end
 
-    def truncatewords(input, words = 15, truncate_string = "...".freeze)
+    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(" ".freeze) + 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.
@@ -86,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)
@@ -102,121 +76,69 @@ module Liquid
     end
 
     def strip_html(input)
-      empty = ''.freeze
+      input.to_s.gsub(/<script.*?<\/script>/m, '').gsub(/<!--.*?-->/m, '').gsub(/<style.*?<\/style>/m, '').gsub(/<.*?>/m, '')
-      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
     end
 
     # Remove all newlines from the string
     def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, ''.freeze)
+      input.to_s.gsub(/\r?\n/, '')
     end
 
     # Join elements of the array with certain character between them
-    def join(input, glue = ' '.freeze)
+    def join(input, glue = ' ')
-      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)
       if property.nil?
         ary.sort
-      elsif ary.empty? # The next two cases assume a non-empty array.
+      elsif ary.first.respond_to?('[]') and !ary.first[property].nil?
-        []
+        ary.sort {|a,b| a[property] <=> b[property] }
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
+      elsif ary.first.respond_to?(property)
-        ary.sort do |a, b|
+        ary.sort {|a,b| a.send(property) <=> b.send(property) }
-          a = a[property]
-          b = b[property]
-          if a && b
-            a <=> b
-          else
-            a ? -1 : 1
-          end
-        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)
-
-      if property.nil?
-        ary.sort { |a, b| a.casecmp(b) }
-      elsif ary.empty? # The next two cases assume a non-empty array.
-        []
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        ary.sort { |a, b| a[property].casecmp(b[property]) }
-      end
-    end
-
-    # Remove duplicate elements from an array
-    # provide optional property with which to determine uniqueness
-    def uniq(input, property = nil)
-      ary = InputIterator.new(input)
-
-      if property.nil?
-        ary.uniq
-      elsif ary.empty? # The next two cases assume a non-empty array.
-        []
-      elsif ary.first.respond_to?(:[])
-        ary.uniq{ |a| a[property] }
       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".freeze
+        if property == "to_liquid"
           e
         elsif e.respond_to?(:[])
-          r = e[property]
+          e[property]
-          r.is_a?(Proc) ? r.call : r
         end
       end
     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?(:[])
-        ary.reject{ |a| a[property].nil? }
-      end
-    end
-
     # Replace occurrences of a string with another
-    def replace(input, string, replacement = ''.freeze)
+    def replace(input, string, replacement = '')
-      input.to_s.gsub(string.to_s, replacement.to_s)
+      input.to_s.gsub(string, replacement.to_s)
     end
 
     # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = ''.freeze)
+    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, ''.freeze)
+      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, ''.freeze)
+      input.to_s.sub(string, '')
     end
 
     # add one string to another
@@ -224,13 +146,6 @@ module Liquid
       input.to_s + string.to_s
     end
 
-    def concat(input, array)
-      unless array.respond_to?(:to_ary)
-        raise ArgumentError.new("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
@@ -238,10 +153,10 @@ module Liquid
 
     # Add <br /> tags in front of all newlines in input string
     def newline_to_br(input)
-      input.to_s.gsub(/\n/, "<br />\n".freeze)
+      input.to_s.gsub(/\n/, "<br />\n")
     end
 
-    # Reformat a date using Ruby's core Time#strftime( string ) -> string
+    # Reformat a date
     #
     #   %a - The abbreviated weekday name (``Sun'')
     #   %A - The  full  weekday  name (``Sunday'')
@@ -255,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
@@ -270,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
 
+      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
@@ -298,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, :+)
@@ -322,97 +250,46 @@ 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 default(input, default_value = ''.freeze)
-      if !input || input.respond_to?(:empty?) && input.empty?
-        default_value
-      else
-        input
-      end
     end
 
     private
 
-    def apply_operation(input, operand, operation)
+    def flatten_if_necessary(input)
-      result = Utils.to_number(input).send(operation, Utils.to_number(operand))
+      ary = if input.is_a?(Array)
-      result.is_a?(BigDecimal) ? result.to_f : result
-    end
-
-    class InputIterator
-      include Enumerable
-
-      def initialize(input)
-        @input = if input.is_a?(Array)
         input.flatten
-        elsif input.is_a?(Hash)
+      elsif input.is_a?(Enumerable) && !input.is_a?(Hash)
-          [input]
-        elsif input.is_a?(Enumerable)
         input
       else
-          Array(input)
+        [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 join(glue)
+    def apply_operation(input, operand, operation)
-        to_a.join(glue.to_s)
+      result = to_number(input).send(operation, to_number(operand))
-      end
+      result.is_a?(BigDecimal) ? result.to_f : result
-
-      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
 

lib/liquid/strainer.rb

@@ -1,19 +1,19 @@
 require 'set'
 
 module Liquid
+
   # Strainer is the parent class for the filters system.
   # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
   #
   # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
   # Context#add_filters or Template.register_filter
   class Strainer #:nodoc:
-    @@global_strainer = Class.new(Strainer) do
+    @@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
 
@@ -21,46 +21,43 @@ module Liquid
       @context = context
     end
 
-    class << self
-      attr_reader :filter_methods
-    end
-
-    def self.add_filter(filter)
-      raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-      unless self.include?(filter)
-        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
-        if invokable_non_public_methods.any?
-          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
-        else
-          send(:include, filter)
-          @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
-        end
-      end
-    end
-
     def self.global_filter(filter)
-      @@strainer_class_cache.clear
+      raise ArgumentError, "Passed filter is not a module" unless filter.is_a?(Module)
-      @@global_strainer.add_filter(filter)
+      add_known_filter(filter)
+      @@filters << filter unless @@filters.include?(filter)
     end
 
-    def self.invokable?(method)
+    def self.add_known_filter(filter)
-      @filter_methods.include?(method.to_s)
+      unless @@known_filters.include?(filter)
+        @@method_blacklist ||= Set.new(Strainer.instance_methods.map(&:to_s))
+        new_methods = filter.instance_methods.map(&:to_s)
+        new_methods.reject!{ |m| @@method_blacklist.include?(m) }
+        @@known_methods.merge(new_methods)
+        @@known_filters.add(filter)
+      end
+    end
+
+    def self.strainer_class_cache
+      @@strainer_class_cache
     end
 
     def self.create(context, filters = [])
-      @@strainer_class_cache[filters].new(context)
+      filters = @@filters + filters
+      strainer_class_cache[filters].new(context)
     end
 
     def invoke(method, *args)
-      if self.class.invokable?(method)
+      if invokable?(method)
         send(method, *args)
-      elsif @context && @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

lib/liquid/tablerowloop_drop.rb

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

lib/liquid/tag.rb

@@ -1,43 +1,56 @@
 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, options)
+      # Forgive me Matz for I have sinned. I know this code is weird
-        tag = new(tag_name, markup, options)
+      # but it was necessary to maintain API compatibility.
-        tag.parse(tokenizer)
+      new_tag = self.allocate
-        tag
+      new_tag.options = options
+      new_tag.send(:initialize, tag_name, markup, tokens)
+      new_tag
     end
 
-      private :new
+    def initialize(tag_name, markup, tokens)
-    end
-
-    def initialize(tag_name, markup, parse_context)
       @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)
-      ''.freeze
+      ''
     end
 
     def blank?
-      false
+      @blank || false
+    end
+
+    def parse_with_selected_parser(markup)
+      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
+
+    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

lib/liquid/tags/assign.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Assign sets a variable in your template.
   #
   #   {% assign foo = 'monkey' %}
@@ -8,44 +9,30 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
+    Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       if markup =~ Syntax
         @to = $1
-        @from = Variable.new($2, options)
+        @from = Variable.new($2)
       else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign")
       end
+
+      super
     end
 
     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)
-      ''.freeze
+      ''
     end
 
     def blank?
       true
     end
-
-    private
-
-    def assign_score_of(val)
-      if val.instance_of?(String)
-        val.length
-      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
   end
 
-  Template.register_tag('assign'.freeze, Assign)
+  Template.register_tag('assign', Assign)
 end

lib/liquid/tags/break.rb

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

lib/liquid/tags/capture.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
   #   {% capture heading %}
@@ -11,22 +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 = $1
       else
         raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
       end
+
+      super
     end
 
     def render(context)
       output = super
       context.scopes.last[@to] = output
-      context.resource_limits.assign_score += output.length
+      context.increment_used_resources(:assign_score_current, output)
-      ''.freeze
+      ''
     end
 
     def blank?
@@ -34,5 +36,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('capture'.freeze, Capture)
+  Template.register_tag('capture', Capture)
 end

lib/liquid/tags/case.rb

@@ -1,35 +1,30 @@
 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
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       @blocks = []
 
       if markup =~ Syntax
-        @left = Expression.parse($1)
+        @left = $1
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case"))
-      end
       end
 
-    def parse(tokens)
+      super
-      body = BlockBody.new
-      while parse_body(body, tokens)
-        body = @blocks.last.attachment
-      end
     end
 
     def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
     end
 
     def unknown_tag(tag, markup, tokens)
+      @nodelist = []
       case tag
-      when 'when'.freeze
+      when 'when'
         record_when_condition(markup)
-      when 'else'.freeze
+      when 'else'
         record_else_condition(markup)
       else
         super
@@ -43,10 +38,10 @@ module Liquid
         output = ''
         @blocks.each do |block|
           if block.else?
-            return block.attachment.render(context) if execute_else_block
+            return render_all(block.attachment, context) if execute_else_block
           elsif block.evaluate(context)
             execute_else_block = false
-            output << block.attachment.render(context)
+            output << render_all(block.attachment, context)
           end
         end
         output
@@ -56,31 +51,30 @@ module Liquid
     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.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
+        if not markup =~ WhenSyntax
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when"))
         end
 
         markup = $2
 
-        block = Condition.new(@left, '=='.freeze, Expression.parse($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.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
+        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
   end
 
-  Template.register_tag('case'.freeze, Case)
+  Template.register_tag('case', Case)
 end

lib/liquid/tags/comment.rb

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

lib/liquid/tags/continue.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Continue tag to be used to break out of a for loop.
   #
   # == Basic Usage:
@@ -9,10 +10,12 @@ module Liquid
   #    {% endfor %}
   #
   class Continue < Tag
+
     def interrupt
       ContinueInterrupt.new
     end
+
   end
 
-  Template.register_tag('continue'.freeze, Continue)
+  Template.register_tag('continue', Continue)
 end

lib/liquid/tags/cycle.rb

@@ -13,29 +13,29 @@ module Liquid
   #
   class Cycle < Tag
     SimpleSyntax = /\A#{QuotedFragment}+/o
-    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       case markup
       when NamedSyntax
         @variables = variables_from_string($2)
-        @name = Expression.parse($1)
+        @name = $1
       when SimpleSyntax
         @variables = variables_from_string(markup)
-        @name = @variables.to_s
+        @name = "'#{@variables.to_s}'"
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle"))
       end
+      super
     end
 
     def render(context)
       context.registers[:cycle] ||= Hash.new(0)
 
       context.stack do
-        key = context.evaluate(@name)
+        key = context[@name]
         iteration = context.registers[:cycle][key]
-        result = context.evaluate(@variables[iteration])
+        result = context[@variables[iteration]]
         iteration += 1
         iteration  = 0  if iteration >= @variables.size
         context.registers[:cycle][key] = iteration
@@ -43,12 +43,15 @@ module Liquid
       end
     end
 
-    private
+    def blank?
+      false
+    end
 
+    private
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        $1 ? Expression.parse($1) : nil
+        $1 ? $1 : nil
       end.compact
     end
   end

lib/liquid/tags/decrement.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # decrement is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
   #     multiple instantiations of the template.
@@ -18,18 +19,21 @@ 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(context)
       value = context.environments.first[@variable] ||= 0
-      value -= 1
+      value = value - 1
       context.environments.first[@variable] = value
       value.to_s
     end
+
+    private
   end
 
-  Template.register_tag('decrement'.freeze, Decrement)
+  Template.register_tag('decrement', Decrement)
 end

lib/liquid/tags/for.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # "For" iterates over an array or collection.
   # Several useful variables are available to you within the loop.
   #
@@ -23,7 +24,7 @@ module Liquid
   #      {{ item.name }}
   #    {% end %}
   #
-  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
+  #  To reverse the for loop simply use {% for item in collection reversed %}
   #
   # == Available variables:
   #
@@ -41,41 +42,84 @@ module Liquid
   #                   where 0 is the last item.
   # forloop.first:: Returns true if the item is the first item.
   # forloop.last:: Returns true if the item is the last item.
-  # forloop.parentloop:: Provides access to the parent loop, if present.
   #
   class For < Block
     Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      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'.freeze
+      return super unless tag == 'else'
-      @else_block = BlockBody.new
+      @nodelist = @else_block = []
     end
 
     def render(context)
-      segment = collection_segment(context)
+      context.registers[:for] ||= Hash.new(0)
 
-      if segment.empty?
+      collection = context[@collection_name]
-        render_else(context)
+      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, segment)
+        context[@attributes['offset']].to_i
       end
+
+      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
@@ -83,113 +127,48 @@ module Liquid
     def lax_parse(markup)
       if markup =~ Syntax
         @variable_name = $1
-        collection_name = $2
+        @collection_name = $2
-        @reversed = !!$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.new(options[:locale].t("errors.syntax.for".freeze))
+        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.new(options[:locale].t("errors.syntax.for_invalid_in".freeze)) unless p.id?('in'.freeze)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in"))  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')
-      @reversed = p.id?('reversed'.freeze)
 
+      @attributes = {}
       while p.look(:id) && p.look(:colon, 1)
-        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
+        unless attribute = p.id?('limit') || p.id?('offset')
-          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
+          raise SyntaxError.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)
-      offsets = context.registers[:for] ||= Hash.new(0)
-
-      from = if @from == :continue
-        offsets[@name].to_i
-      else
-        context.evaluate(@from).to_i
-      end
-
-      collection = context.evaluate(@collection_name)
-      collection = collection.to_a if collection.is_a?(Range)
-
-      limit = context.evaluate(@limit)
-      to = limit ? limit.to_i + from : nil
-
-      segment = Utils.slice_collection(collection, from, to)
-      segment.reverse! if @reversed
-
-      offsets[@name] = from + segment.length
-
-      segment
-    end
-
-    def render_segment(context, segment)
-      for_stack = context.registers[:for_stack] ||= []
-      length = segment.length
-
-      result = ''
-
-      context.stack do
-        loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
-
-        for_stack.push(loop_vars)
-
-        begin
-          context['forloop'.freeze] = loop_vars
-
-          segment.each_with_index do |item, index|
-            context[@variable_name] = item
-            result << @for_block.render(context)
-            loop_vars.send(:increment!)
-
-            # Handle any interrupts if they exist.
-            if context.interrupt?
-              interrupt = context.pop_interrupt
-              break if interrupt.is_a? BreakInterrupt
-              next if interrupt.is_a? ContinueInterrupt
-            end
-          end
-        ensure
-          for_stack.pop
-        end
-      end
-
-      result
-    end
-
-    def set_attribute(key, expr)
-      case key
-      when 'offset'.freeze
-        @from = if expr == 'continue'.freeze
-          :continue
-        else
-          Expression.parse(expr)
-        end
-      when 'limit'.freeze
-        @limit = Expression.parse(expr)
-      end
-    end
-
       def render_else(context)
-      @else_block ? @else_block.render(context) : ''.freeze
+        return @else_block ? [render_all(@else_block, context)] : ''
+      end
+
+      def iterable?(collection)
+        collection.respond_to?(:each) || Utils.non_blank_string?(collection)
       end
   end
 
-  Template.register_tag('for'.freeze, For)
+  Template.register_tag('for', For)
 end

lib/liquid/tags/if.rb

@@ -14,23 +14,18 @@ module Liquid
     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)
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
       @blocks = []
-      push_block('if'.freeze, markup)
+      push_block('if', markup)
-    end
+      super
-
-    def parse(tokens)
-      while parse_body(@blocks.last.attachment, tokens)
-      end
     end
 
     def nodelist
-      @blocks.map(&:attachment)
+      @blocks.map(&:attachment).flatten
     end
 
     def unknown_tag(tag, markup, tokens)
-      if ['elsif'.freeze, 'else'.freeze].include?(tag)
+      if ['elsif', 'else'].include?(tag)
         push_block(tag, markup)
       else
         super
@@ -41,39 +36,39 @@ module Liquid
       context.stack do
         @blocks.each do |block|
           if block.evaluate(context)
-            return block.attachment.render(context)
+            return render_all(block.attachment, context)
           end
         end
-        ''.freeze
+        ''
       end
     end
 
     private
 
       def push_block(tag, markup)
-      block = if tag == 'else'.freeze
+        block = if tag == 'else'
           ElseCondition.new
         else
           parse_with_selected_parser(markup)
         end
 
         @blocks.push(block)
-      block.attach(BlockBody.new)
+        @nodelist = block.attach(Array.new)
       end
 
       def lax_parse(markup)
-      expressions = markup.scan(ExpressionsAndOperators)
+        expressions = markup.scan(ExpressionsAndOperators).reverse
-      raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless expressions.shift =~ Syntax
 
-      condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+        condition = Condition.new($1, $2, $3)
 
-      until expressions.empty?
+        while not expressions.empty?
-        operator = expressions.pop.to_s.strip
+          operator = (expressions.shift).to_s.strip
 
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless expressions.shift.to_s =~ Syntax
 
-        new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+          new_condition = Condition.new($1, $2, $3)
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
+          raise(SyntaxError.new(options[:locale].t("errors.syntax.if"))) unless BOOLEAN_OPERATORS.include?(operator)
           new_condition.send(operator, condition)
           condition = new_condition
         end
@@ -83,23 +78,23 @@ module Liquid
 
       def strict_parse(markup)
         p = Parser.new(markup)
-      condition = parse_binary_comparison(p)
-      p.consume(:end_of_string)
-      condition
-    end
 
-    def parse_binary_comparison(p)
         condition = parse_comparison(p)
-      if op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+
-        condition.send(op, parse_binary_comparison(p))
+        while op = (p.id?('and') || p.id?('or'))
+          new_cond = parse_comparison(p)
+          new_cond.send(op, condition)
+          condition = new_cond
         end
+        p.consume(:end_of_string)
+
         condition
       end
 
       def parse_comparison(p)
-      a = Expression.parse(p.expression)
+        a = p.expression
         if op = p.consume?(:comparison)
-        b = Expression.parse(p.expression)
+          b = p.expression
           Condition.new(a, op, b)
         else
           Condition.new(a)
@@ -107,5 +102,5 @@ module Liquid
       end
   end
 
-  Template.register_tag('if'.freeze, If)
+  Template.register_tag('if', If)
 end

lib/liquid/tags/ifchanged.rb

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

lib/liquid/tags/include.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Include allows templates to relate with other templates
   #
   # Simply include another template:
@@ -16,53 +17,38 @@ module Liquid
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, tokens)
-      super
-
       if markup =~ Syntax
 
-        template_name = $1
+        @template_name = $1
-        variable_name = $3
+        @variable_name = $3
-
-        @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.new(options[:locale].t("errors.syntax.include".freeze))
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include"))
-      end
       end
 
-    def parse(_tokens)
+      super
+    end
+
+    def blank?
+      false
     end
 
     def render(context)
-      template_name = context.evaluate(@template_name_expr)
+      partial = load_cached_partial(context)
-      raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name
+      variable = context[@variable_name || @template_name[1..-2]]
 
-      partial = load_cached_partial(template_name, context)
-      context_variable_name = template_name.split('/'.freeze).last
-
-      variable = if @variable_name_expr
-        context.evaluate(@variable_name_expr)
-      else
-        context.find_variable(template_name, raise_on_not_found: false)
-      end
-
-      old_template_name = context.template_name
-      old_partial = context.partial
-      begin
-        context.template_name = template_name
-        context.partial = true
       context.stack do
         @attributes.each do |key, value|
-            context[key] = context.evaluate(value)
+          context[key] = context[value]
         end
 
+        context_variable_name = @template_name[1..-2].split('/').last
         if variable.is_a?(Array)
           variable.collect do |var|
             context[context_variable_name] = var
@@ -73,30 +59,18 @@ module Liquid
           partial.render(context)
         end
       end
-      ensure
-        context.template_name = old_template_name
-        context.partial = old_partial
-      end
     end
 
     private
-
+      def load_cached_partial(context)
-    alias_method :parse_context, :options
-    private :parse_context
-
-    def load_cached_partial(template_name, 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)
-      begin
+        partial = Liquid::Template.parse(source)
-        parse_context.partial = true
-        partial = Liquid::Template.parse(source, parse_context)
-      ensure
-        parse_context.partial = false
-      end
         cached_partials[template_name] = partial
         context.registers[:cached_partials] = cached_partials
         partial
@@ -105,9 +79,17 @@ module Liquid
       def read_template_from_file_system(context)
         file_system = context.registers[:file_system] || Liquid::Template.file_system
 
-      file_system.read_template_file(context.evaluate(@template_name_expr))
+        # 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'.freeze, Include)
+  Template.register_tag('include', Include)
 end

lib/liquid/tags/increment.rb

@@ -15,9 +15,9 @@ 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(context)
@@ -25,7 +25,11 @@ module Liquid
       context.environments.first[@variable] = value + 1
       value.to_s
     end
+
+    def blank?
+      false
+    end
   end
 
-  Template.register_tag('increment'.freeze, Increment)
+  Template.register_tag('increment', Increment)
 end

lib/liquid/tags/raw.rb

@@ -1,47 +1,19 @@
 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 << $1 if $1 != "".freeze
+          @nodelist << $1 if $1 != ""
           return if block_delimiter == $2
         end
-        @body << token unless token.empty?
+        @nodelist << token if not token.empty?
-      end
-
-      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
-    end
-
-    def render(_context)
-      @body
-    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.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name))
       end
     end
   end
 
-  Template.register_tag('raw'.freeze, Raw)
+  Template.register_tag('raw', Raw)
 end

lib/liquid/tags/table_row.rb

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

lib/liquid/tags/unless.rb

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

lib/liquid/template.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Templates are central to liquid.
   # Interpretating templates is a two step process. First you compile the
   # source code you got. During compile time some extensive error checking is performed.
@@ -13,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)
-        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
-      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
@@ -87,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
@@ -104,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
@@ -155,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
@@ -165,17 +110,11 @@ module Liquid
     #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return ''.freeze if @root.nil?
+      return '' if @root.nil?
 
       context = case args.first
       when Liquid::Context
-        c = args.shift
+        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)
@@ -191,22 +130,24 @@ module Liquid
       when Hash
         options = args.pop
 
-        registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
+        if options[:registers].is_a?(Hash)
-
+          self.registers.merge!(options[:registers])
-        apply_options_to_context(context, options)
-      when Module, Array
-        context.add_filters(args.pop)
         end
 
-      # Retrying a render resets resource usage
+        if options[:filters]
-      context.resource_limits.reset
+          context.add_filters(options[:filters])
+        end
+
+      when Module
+        context.add_filters(args.pop)
+      when Array
+        context.add_filters(args.pop)
+      end
 
       begin
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
-        result = with_profiling(context) do
+        result = @root.render(context)
-          @root.render(context)
-        end
         result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
@@ -216,39 +157,15 @@ module Liquid
     end
 
     def render!(*args)
-      @rethrow_errors = true
+      @rethrow_errors = true; render(*args)
-      render(*args)
     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

lib/liquid/tokenizer.rb

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

lib/liquid/utils.rb

@@ -1,24 +1,27 @@
 module Liquid
   module Utils
+
     def self.slice_collection(collection, from, to)
-      if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
+      if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
       else
         slice_collection_using_each(collection, from, to)
       end
     end
 
+    def self.non_blank_string?(collection)
+      collection.is_a?(String) && collection != ''
+    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
@@ -32,52 +35,5 @@ module Liquid
 
       segments
     end
-
-    def self.to_integer(num)
-      return num if num.is_a?(Integer)
-      num = num.to_s
-      begin
-        Integer(num)
-      rescue ::ArgumentError
-        raise Liquid::ArgumentError, "invalid integer"
-      end
-    end
-
-    def self.to_number(obj)
-      case obj
-      when Float
-        BigDecimal.new(obj.to_s)
-      when Numeric
-        obj
-      when String
-        (obj.strip =~ /\A-?\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
-      else
-        if obj.respond_to?(:to_number)
-          obj.to_number
-        else
-          0
-        end
-      end
-    end
-
-    def self.to_date(obj)
-      return obj if obj.respond_to?(:strftime)
-
-      if obj.is_a?(String)
-        return nil if obj.empty?
-        obj = obj.downcase
-      end
-
-      case obj
-      when 'now'.freeze, 'today'.freeze
-        Time.now
-      when /\A\d+\z/, Integer
-        Time.at(obj.to_i)
-      when String
-        Time.parse(obj)
-      end
-    rescue ::ArgumentError
-      nil
-    end
   end
 end

lib/liquid/variable.rb

@@ -1,4 +1,5 @@
 module Liquid
+
   # Holds variables. Variables are only loaded "just in time"
   # and are not evaluated as part of the render stage
   #
@@ -10,126 +11,98 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterParser = /(?:#{FilterSeparator}|(?:\s*(?:#{QuotedFragment}|#{ArgumentSeparator})\s*)+)/o
-    attr_accessor :filters, :name, :line_number
+    EasyParse = /\A *(\w+(?:\.\w+)*) *\z/
-    attr_reader :parse_context
+    attr_accessor :filters, :name, :warnings
-    alias_method :options, :parse_context
-    include ParserSwitching
 
-    def initialize(markup, parse_context)
+    def initialize(markup, options = {})
       @markup  = markup
       @name    = nil
-      @parse_context = parse_context
+      @options = options || {}
-      @line_number = parse_context.line_number
       
-      parse_with_selected_parser(markup)
+
+      case @options[:error_mode] || Template.error_mode
+      when :strict then strict_parse(markup)
+      when :lax    then lax_parse(markup)
+      when :warn
+        begin
+          strict_parse(markup)
+        rescue SyntaxError => e
+          @warnings ||= []
+          @warnings << e
+          lax_parse(markup)
         end
-
-    def raw
-      @markup
       end
-
-    def markup_context(markup)
-      "in \"{{#{markup}}}\""
     end
 
     def lax_parse(markup)
       @filters = []
-      return unless markup =~ /(#{QuotedFragment})(.*)/om
+      if match = markup.match(/\s*(#{QuotedFragment})(.*)/o)
-
+        @name = match[1]
-      name_markup = $1
+        if match[2].match(/#{FilterSeparator}\s*(.*)/o)
-      filter_markup = $2
+          filters = Regexp.last_match(1).scan(FilterParser)
-      @name = Expression.parse(name_markup)
-      if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
-        filters = $1.scan(FilterParser)
           filters.each do |f|
-          next unless f =~ /\w+/
+            if matches = f.match(/\s*(\w+)/)
-          filtername = Regexp.last_match(0)
+              filtername = matches[1]
               filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-          @filters << parse_filter_expressions(filtername, filterargs)
+              @filters << [filtername, filterargs]
+            end
+          end
         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
-
-      obj = context.apply_global_filter(obj)
-
-      taint_check(context, obj)
-
-      obj
-    end
-
-    private
-
-    def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args = []
         keyword_args = {}
-      unparsed_args.each do |a|
+        filter[1].to_a.each do |a|
           if matches = a.match(/\A#{TagAttributes}\z/o)
-          keyword_args[matches[1]] = Expression.parse(matches[2])
+            keyword_args[matches[1]] = context[matches[2]]
           else
-          filter_args << Expression.parse(a)
+            filterargs << context[a]
           end
         end
-      result = [filter_name, filter_args]
+        filterargs << keyword_args unless keyword_args.empty?
-      result << keyword_args unless keyword_args.empty?
+        begin
-      result
+          output = context.invoke(filter[0], output, *filterargs)
-    end
+        rescue FilterNotFound
-
+          raise FilterNotFound, "Error - filter '#{filter[0]}' in '#{@markup.strip}' could not be found."
-    def evaluate_filter_expressions(context, filter_args, filter_kwargs)
+        end
-      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
   end

lib/liquid/variable_lookup.rb

@@ -1,82 +0,0 @@
-module Liquid
-  class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, '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($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($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
-  end
-end

lib/liquid/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 module Liquid
-  VERSION = "4.0.0"
+  VERSION = "3.0.0"
 end

liquid.gemspec

@@ -1,6 +1,6 @@
 # encoding: utf-8
 lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
+$:.unshift lib unless $:.include?(lib)
 
 require "liquid/version"
 
@@ -9,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.required_ruby_version     = ">= 2.1.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.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

performance/benchmark.rb

@@ -1,18 +1,12 @@
-require 'benchmark/ips'
+require 'rubygems'
-require_relative 'theme_runner'
+require 'benchmark'
+require File.dirname(__FILE__) + '/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
+

performance/profile.rb

@@ -1,24 +1,19 @@
-require 'stackprof'
+require 'rubygems'
-require_relative 'theme_runner'
+require 'ruby-prof' rescue fail("install ruby-prof extension/gem")
+require File.dirname(__FILE__) + '/theme_runner'
 
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
-profiler.run
 
-[:cpu, :object].each do |profile_type|
+puts '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

performance/shopify/comment_form.rb

@@ -1,15 +1,15 @@
 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 = $1
       @attributes = {}
     else
       raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
     end
+
+    super
   end
 
   def render(context)
@@ -28,6 +28,6 @@ class CommentForm < Liquid::Block
   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

performance/shopify/database.rb

@@ -1,11 +1,11 @@
 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|
@@ -39,7 +39,7 @@ module Database
   end
 end
 
-if __FILE__ == $PROGRAM_NAME
+if __FILE__ == $0
   p Database.tables['collections']['frontpage'].keys
   #p Database.tables['blog']['articles']
 end

performance/shopify/json_filter.rb

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

performance/shopify/liquid.rb

@@ -1,13 +1,13 @@
-$:.unshift __dir__ + '/../../lib'
+$:.unshift File.dirname(__FILE__) + '/../../lib'
-require_relative '../../lib/liquid'
+require File.dirname(__FILE__) + '/../../lib/liquid'
 
-require_relative 'comment_form'
+require File.dirname(__FILE__) + '/comment_form'
-require_relative 'paginate'
+require File.dirname(__FILE__) + '/paginate'
-require_relative 'json_filter'
+require File.dirname(__FILE__) + '/json_filter'
-require_relative 'money_filter'
+require File.dirname(__FILE__) + '/money_filter'
-require_relative 'shop_filter'
+require File.dirname(__FILE__) + '/shop_filter'
-require_relative 'tag_filter'
+require File.dirname(__FILE__) + '/tag_filter'
-require_relative 'weight_filter'
+require File.dirname(__FILE__) + '/weight_filter'
 
 Liquid::Template.register_tag 'paginate', Paginate
 Liquid::Template.register_tag 'form', CommentForm

performance/shopify/money_filter.rb

@@ -1,4 +1,5 @@
 module MoneyFilter
+
   def money_with_currency(money)
     return '' if money.nil?
     sprintf("$ %.2f USD", money/100.0)

performance/shopify/paginate.rb

@@ -1,8 +1,8 @@
 class Paginate < Liquid::Block
   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 = $1
@@ -19,6 +19,8 @@ class Paginate < Liquid::Block
     else
       raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
     end
+
+    super
   end
 
   def render(context)
@@ -51,13 +53,14 @@ class Paginate < Liquid::Block
 
       if page_count > 2
         1.upto(page_count-1) do |page|
+
           if current_page == page
             pagination['parts'] << no_link(page)
           elsif page == 1
             pagination['parts'] << link(page, page)
           elsif page == page_count -1
             pagination['parts'] << link(page, page)
-          elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
+          elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
             next if hellip_break
             pagination['parts'] << no_link('&hellip;')
             hellip_break = true
@@ -70,7 +73,7 @@ class Paginate < Liquid::Block
         end
       end
 
-      super
+      render_all(@nodelist, context)
     end
   end
 

performance/shopify/shop_filter.rb

@@ -1,4 +1,5 @@
 module ShopFilter
+
   def asset_url(input)
     "/files/1/[shop_id]/[shop_id]/assets/#{input}"
   end
@@ -20,11 +21,11 @@ module ShopFilter
   end
 
   def link_to(link, url, title="")
-    %(<a href="#{url}" title="#{title}">#{link}</a>)
+    %|<a href="#{url}" title="#{title}">#{link}</a>|
   end
 
   def img_tag(url, alt="")
-    %(<img src="#{url}" alt="#{alt}" />)
+    %|<img src="#{url}" alt="#{alt}" />|
   end
 
   def link_to_vendor(vendor)
@@ -44,14 +45,15 @@ 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 =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
       raise ArgumentError, 'filter "size" can only be called on product images'
     end
@@ -67,6 +69,7 @@ module ShopFilter
   end
 
   def default_pagination(paginate)
+
     html = []
     html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
 
@@ -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

performance/shopify/tag_filter.rb

@@ -1,4 +1,5 @@
 module TagFilter
+
   def link_to_tag(label, tag)
     "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
   end
@@ -20,4 +21,5 @@ module TagFilter
     tags = (@context['current_tags'] - [tag]).uniq
     "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
   end
+
 end

performance/shopify/weight_filter.rb

@@ -1,4 +1,5 @@
 module WeightFilter
+
   def weight(grams)
     sprintf("%.2f", grams / 1000)
   end
@@ -6,4 +7,5 @@ module WeightFilter
   def weight_with_unit(grams)
     "#{weight(grams)} kg"
   end
+
 end

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

performance/theme_runner.rb

@@ -6,115 +6,115 @@
 # Shopify which is likely the biggest user of liquid in the world which something to the tune of several
 # million Template#render calls a day.
 
-require_relative 'shopify/liquid'
+require 'rubygems'
-require_relative 'shopify/database'
+require 'active_support'
+require 'yaml'
+require 'digest/md5'
+require File.dirname(__FILE__) + '/shopify/liquid'
+require File.dirname(__FILE__) + '/shopify/database.rb'
 
 class ThemeRunner
   class FileSystem
+
     def initialize(path)
       @path = path
     end
 
     # Called by Liquid to retrieve a template file
-    def read_template_file(template_path)
+    def read_template_file(template_path, context)
       File.read(@path + '/' + template_path + '.liquid')
     end
   end
 
-  # Initialize a new liquid ThemeRunner instance
+  # Load all templates into memory, do this now so that
-  # Will load all templates into memory, do this now so that we don't profile IO.
+  # we don't profile IO.
   def initialize
-    @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
+    @tests = Dir[File.dirname(__FILE__) + '/tests/**/*.liquid'].collect do |test|
       next if File.basename(test) == 'theme.liquid'
 
       theme_path = File.dirname(test) + '/theme.liquid'
-      {
+
-        liquid: File.read(test),
+      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
-        layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
-        template_name: test
-      }
     end.compact
-
-    compile_all_tests
   end
 
-  # `compile` will test just the compilation portion of liquid without any templates
   def compile
-    @tests.each do |test_hash|
+    # Dup assigns because will make some changes to them
-      Liquid::Template.new.parse(test_hash[:liquid])
+
-      Liquid::Template.new.parse(test_hash[:layout])
+    @tests.each do |liquid, layout, template_name|
+
+      tmpl = Liquid::Template.new
+      tmpl.parse(liquid)
+      tmpl = Liquid::Template.new
+      tmpl.parse(layout)
     end
   end
 
-  # `run` is called to benchmark rendering and compiling at the same time
    def run
-    each_test do |liquid, layout, assigns, page_template, template_name|
-      compile_and_render(liquid, layout, assigns, page_template, template_name)
-    end
-  end
-
-  # `render` is called to benchmark just the render portion of liquid
-  def render
-    @compiled_tests.each do |test|
-      tmpl = test[:tmpl]
-      assigns = test[:assigns]
-      layout = test[:layout]
-
-      if layout
-        assigns['content_for_layout'] = tmpl.render!(assigns)
-        layout.render!(assigns)
-      else
-        tmpl.render!(assigns)
-      end
-    end
-  end
-
-  private
-
-  def compile_and_render(template, layout, assigns, page_template, template_file)
-    compiled_test = compile_test(template, layout, assigns, page_template, template_file)
-    assigns['content_for_layout'] = compiled_test[:tmpl].render!(assigns)
-    compiled_test[:layout].render!(assigns) if layout
-  end
-
-  def compile_all_tests
-    @compiled_tests = []
-    each_test do |liquid, layout, assigns, page_template, template_name|
-      @compiled_tests << compile_test(liquid, layout, assigns, page_template, template_name)
-    end
-    @compiled_tests
-  end
-
-  def compile_test(template, layout, assigns, page_template, template_file)
-    tmpl = init_template(page_template, template_file)
-    parsed_template = tmpl.parse(template).dup
-
-    if layout
-      parsed_layout = tmpl.parse(layout)
-      { tmpl: parsed_template, assigns: assigns, layout: parsed_layout }
-    else
-      { tmpl: parsed_template, assigns: assigns }
-    end
-  end
-
-  # utility method with similar functionality needed in `compile_all_tests` and `run`
-  def each_test
     # Dup assigns because will make some changes to them
     assigns = Database.tables.dup
 
-    @tests.each do |test_hash|
+    @tests.each do |liquid, layout, template_name|
-      # Compute page_template outside of profiler run, uninteresting to profiler
+
-      page_template = File.basename(test_hash[:template_name], File.extname(test_hash[:template_name]))
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
-      yield(test_hash[:liquid], test_hash[:layout], assigns, page_template, test_hash[:template_name])
+      page_template = File.basename(template_name, File.extname(template_name))
+      compile_and_render(liquid, layout, assigns, page_template, template_name)
+
     end
   end
 
-  # set up a new Liquid::Template object for use in `compile_and_render` and `compile_test`
+
-  def init_template(page_template, template_file)
+  def run_profile
+    RubyProf.measure_mode = RubyProf::WALL_TIME
+
+    # Dup assigns because will make some changes to them
+    assigns = Database.tables.dup
+
+    @tests.each do |liquid, layout, template_name|
+
+      # Compute page_tempalte outside of profiler run, uninteresting to profiler
+      html = nil
+      page_template = File.basename(template_name, File.extname(template_name))
+
+      unless @started
+        RubyProf.start
+        RubyProf.pause
+        @started = true
+      end
+
+      html = nil
+
+      RubyProf.resume
+      html = compile_and_render(liquid, layout, assigns, page_template, template_name)
+      RubyProf.pause
+
+
+      # return the result and the MD5 of the content, this can be used to detect regressions between liquid version
+      $stdout.puts "* rendered template %s, content: %s" % [template_name, Digest::MD5.hexdigest(html)]
+
+      # Uncomment to dump html files to /tmp so that you can inspect for errors
+      # File.open("/tmp/#{File.basename(template_name)}.html", "w+") { |fp| fp <<html}
+    end
+
+    RubyProf.stop
+  end
+
+  def compile_and_render(template, layout, assigns, page_template, template_file)
     tmpl = Liquid::Template.new
     tmpl.assigns['page_title'] = 'Page title'
     tmpl.assigns['template'] = page_template
     tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
-    tmpl
+
+    content_for_layout = tmpl.parse(template).render(assigns)
+
+    if layout
+      assigns['content_for_layout'] = content_for_layout
+      tmpl.parse(layout).render(assigns)
+    else
+      content_for_layout
     end
   end
+end
+
+
+

test/integration/assign_test.rb

@@ -1,48 +0,0 @@
-require 'test_helper'
-
-class AssignTest < Minitest::Test
-  include Liquid
-
-  def test_assign_with_hyphen_in_variable_name
-    template_source = <<-END_TEMPLATE
-    {% assign this-thing = 'Print this-thing' %}
-    {{ this-thing }}
-    END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
-    assert_equal "Print this-thing", rendered.strip
-  end
-
-  def test_assigned_variable
-    assert_template_result('.foo.',
-      '{% assign foo = values %}.{{ foo[0] }}.',
-      'values' => %w(foo bar baz))
-
-    assert_template_result('.bar.',
-      '{% assign foo = values %}.{{ foo[1] }}.',
-      'values' => %w(foo bar baz))
-  end
-
-  def test_assign_with_filter
-    assert_template_result('.bar.',
-      '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
-      'values' => "foo,bar,baz")
-  end
-
-  def test_assign_syntax_error
-    assert_match_syntax_error(/assign/,
-      '{% assign foo not values %}.',
-      'values' => "foo,bar,baz")
-  end
-
-  def test_assign_uses_error_mode
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        Template.parse("{% assign foo = ('X' | downcase) %}")
-      end
-    end
-    with_error_mode(:lax) do
-      assert Template.parse("{% assign foo = ('X' | downcase) %}")
-    end
-  end
-end # AssignTest

test/integration/context_test.rb

@@ -1,32 +0,0 @@
-require 'test_helper'
-
-class ContextTest < Minitest::Test
-  include Liquid
-
-  def test_override_global_filter
-    global = Module.new do
-      def notice(output)
-        "Global #{output}"
-      end
-    end
-
-    local = Module.new do
-      def notice(output)
-        "Local #{output}"
-      end
-    end
-
-    with_global_filter(global) do
-      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, filters: [local])
-    end
-  end
-
-  def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_mode :strict do
-      context = Context.new
-      context.key?('unknown')
-      assert_empty context.errors
-    end
-  end
-end

test/integration/document_test.rb

@@ -1,19 +0,0 @@
-require 'test_helper'
-
-class DocumentTest < Minitest::Test
-  include Liquid
-
-  def test_unexpected_outer_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% else %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: Unexpected outer 'else' tag"
-  end
-
-  def test_unknown_tag
-    exc = assert_raises(SyntaxError) do
-      Template.parse("{% foo %}")
-    end
-    assert_equal exc.message, "Liquid syntax error: Unknown tag 'foo'"
-  end
-end

test/integration/drop_test.rb

@@ -1,273 +0,0 @@
-require 'test_helper'
-
-class ContextDrop < Liquid::Drop
-  def scopes
-    @context.scopes.size
-  end
-
-  def scopes_as_array
-    (1..@context.scopes.size).to_a
-  end
-
-  def loop_pos
-    @context['forloop.index']
-  end
-
-  def liquid_method_missing(method)
-    @context[method]
-  end
-end
-
-class ProductDrop < Liquid::Drop
-  class TextDrop < Liquid::Drop
-    def array
-      ['text1', 'text2']
-    end
-
-    def text
-      'text1'
-    end
-  end
-
-  class CatchallDrop < Liquid::Drop
-    def liquid_method_missing(method)
-      'catchall_method: ' << method.to_s
-    end
-  end
-
-  def texts
-    TextDrop.new
-  end
-
-  def catchall
-    CatchallDrop.new
-  end
-
-  def context
-    ContextDrop.new
-  end
-
-  def user_input
-    "foo".taint
-  end
-
-  protected
-
-  def callmenot
-    "protected"
-  end
-end
-
-class EnumerableDrop < Liquid::Drop
-  def liquid_method_missing(method)
-    method
-  end
-
-  def size
-    3
-  end
-
-  def first
-    1
-  end
-
-  def count
-    3
-  end
-
-  def min
-    1
-  end
-
-  def max
-    3
-  end
-
-  def each
-    yield 1
-    yield 2
-    yield 3
-  end
-end
-
-class RealEnumerableDrop < Liquid::Drop
-  include Enumerable
-
-  def liquid_method_missing(method)
-    method
-  end
-
-  def each
-    yield 1
-    yield 2
-    yield 3
-  end
-end
-
-class DropsTest < Minitest::Test
-  include Liquid
-
-  def test_product_drop
-    tpl = Liquid::Template.parse('  ')
-    assert_equal '  ', tpl.render!('product' => ProductDrop.new)
-  end
-
-  def test_rendering_raises_on_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      assert_raises TaintedError do
-        tpl.render!('product' => ProductDrop.new)
-      end
-    end
-  end
-
-  def test_rendering_warns_on_tainted_attr
-    with_taint_mode(:warn) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      context = Context.new('product' => ProductDrop.new)
-      tpl.render!(context)
-      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
-      assert_equal "variable 'product.user_input' is tainted and was not escaped", context.warnings.first.to_s(false)
-    end
-  end
-
-  def test_rendering_doesnt_raise_on_escaped_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
-      tpl.render!('product' => ProductDrop.new)
-    end
-  end
-
-  def test_drop_does_only_respond_to_whitelisted_methods
-    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
-  end
-
-  def test_drops_respond_to_to_liquid
-    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new)
-    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
-  end
-
-  def test_text_drop
-    output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
-    assert_equal ' text1 ', output
-  end
-
-  def test_catchall_unknown_method
-    output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
-    assert_equal ' catchall_method: unknown ', output
-  end
-
-  def test_catchall_integer_argument_drop
-    output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
-    assert_equal ' catchall_method: 8 ', output
-  end
-
-  def test_text_array_drop
-    output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
-    assert_equal ' text1  text2 ', output
-  end
-
-  def test_context_drop
-    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
-    assert_equal ' carrot ', output
-  end
-
-  def test_nested_context_drop
-    output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
-    assert_equal ' monkey ', output
-  end
-
-  def test_protected
-    output = Liquid::Template.parse(' {{ product.callmenot }} ').render!('product' => ProductDrop.new)
-    assert_equal '  ', output
-  end
-
-  def test_object_methods_not_allowed
-    [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method|
-      output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new)
-      assert_equal '  ', output
-    end
-  end
-
-  def test_scope
-    assert_equal '1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new)
-    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-  end
-
-  def test_scope_though_proc
-    assert_equal '1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] })
-    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
-  end
-
-  def test_scope_with_assigns
-    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
-    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
-    assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
-  end
-
-  def test_scope_from_tags
-    assert_equal '1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
-  end
-
-  def test_access_context_from_drop
-    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3])
-  end
-
-  def test_enumerable_drop
-    assert_equal '123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
-  end
-
-  def test_enumerable_drop_size
-    assert_equal '3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new)
-  end
-
-  def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
-    ["select", "each", "map", "cycle"].each do |method|
-      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-    end
-  end
-
-  def test_some_enumerable_methods_still_get_invoked
-    [ :count, :max ].each do |method|
-      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
-    end
-
-    assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)
-
-    [ :min, :first ].each do |method|
-      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
-    end
-  end
-
-  def test_empty_string_value_access
-    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => '')
-  end
-
-  def test_nil_value_access
-    assert_equal '', Liquid::Template.parse('{{ product[value] }}').render!('product' => ProductDrop.new, 'value' => nil)
-  end
-
-  def test_default_to_s_on_drops
-    assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
-    assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
-  end
-end # DropsTest

test/integration/error_handling_test.rb

@@ -1,260 +0,0 @@
-require 'test_helper'
-
-class ErrorHandlingTest < Minitest::Test
-  include Liquid
-
-  def test_templates_parsed_with_line_numbers_renders_them_in_errors
-    template = <<-LIQUID
-      Hello,
-
-      {{ errors.standard_error }} will raise a standard error.
-
-      Bla bla test.
-
-      {{ errors.syntax_error }} will raise a syntax error.
-
-      This is an argument error: {{ errors.argument_error }}
-
-      Bla.
-    LIQUID
-
-    expected = <<-TEXT
-      Hello,
-
-      Liquid error (line 3): standard error will raise a standard error.
-
-      Bla bla test.
-
-      Liquid syntax error (line 7): syntax error will raise a syntax error.
-
-      This is an argument error: Liquid error (line 9): argument error
-
-      Bla.
-    TEXT
-
-    output = Liquid::Template.parse(template, line_numbers: true).render('errors' => ErrorDrop.new)
-    assert_equal expected, output
-  end
-
-  def test_standard_error
-    template = Liquid::Template.parse(' {{ errors.standard_error }} ')
-    assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
-
-    assert_equal 1, template.errors.size
-    assert_equal StandardError, template.errors.first.class
-  end
-
-  def test_syntax
-    template = Liquid::Template.parse(' {{ errors.syntax_error }} ')
-    assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
-
-    assert_equal 1, template.errors.size
-    assert_equal SyntaxError, template.errors.first.class
-  end
-
-  def test_argument
-    template = Liquid::Template.parse(' {{ errors.argument_error }} ')
-    assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
-
-    assert_equal 1, template.errors.size
-    assert_equal ArgumentError, template.errors.first.class
-  end
-
-  def test_missing_endtag_parse_time_error
-    assert_raises(Liquid::SyntaxError) do
-      Liquid::Template.parse(' {% for a in b %} ... ')
-    end
-  end
-
-  def test_unrecognized_operator
-    with_error_mode(:strict) do
-      assert_raises(SyntaxError) do
-        Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ')
-      end
-    end
-  end
-
-  def test_lax_unrecognized_operator
-    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
-    assert_equal ' Liquid error: Unknown operator =! ', template.render
-    assert_equal 1, template.errors.size
-    assert_equal Liquid::ArgumentError, template.errors.first.class
-  end
-
-  def test_with_line_numbers_adds_numbers_to_parser_errors
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(%q(
-          foobar
-
-          {% "cat" | foobar %}
-
-          bla
-        ),
-        line_numbers: true
-      )
-    end
-
-    assert_match(/Liquid syntax error \(line 4\)/, err.message)
-  end
-
-  def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(%q(
-          foobar
-
-          {%- "cat" | foobar -%}
-
-          bla
-        ),
-        line_numbers: true
-      )
-    end
-
-    assert_match(/Liquid syntax error \(line 4\)/, err.message)
-  end
-
-  def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
-    template = Liquid::Template.parse('
-        foobar
-
-        {% if 1 =! 2 %}ok{% endif %}
-
-        bla
-            ',
-      error_mode: :warn,
-      line_numbers: true
-                                     )
-
-    assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
-      template.warnings.map(&:message)
-  end
-
-  def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
-          foobar
-
-          {% if 1 =! 2 %}ok{% endif %}
-
-          bla
-                ',
-        error_mode: :strict,
-        line_numbers: true
-                            )
-    end
-
-    assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
-  end
-
-  def test_syntax_errors_in_nested_blocks_have_correct_line_number
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
-          foobar
-
-          {% if 1 != 2 %}
-            {% foo %}
-          {% endif %}
-
-          bla
-                ',
-        line_numbers: true
-                            )
-    end
-
-    assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
-  end
-
-  def test_strict_error_messages
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
-    end
-    assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
-
-    err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
-    end
-    assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
-  end
-
-  def test_warnings
-    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
-    assert_equal 3, template.warnings.size
-    assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
-    assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
-    assert_equal 'Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].to_s(false)
-    assert_equal '', template.render
-  end
-
-  def test_warning_line_numbers
-    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
-    assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
-    assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
-    assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
-    assert_equal 3, template.warnings.size
-    assert_equal [1, 2, 3], template.warnings.map(&:line_number)
-  end
-
-  # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
-  def test_exceptions_propagate
-    assert_raises Exception do
-      template = Liquid::Template.parse('{{ errors.exception }}')
-      template.render('errors' => ErrorDrop.new)
-    end
-  end
-
-  def test_default_exception_renderer_with_internal_error
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-
-    output = template.render({ 'errors' => ErrorDrop.new })
-
-    assert_equal 'This is a runtime error: Liquid error (line 1): internal', output
-    assert_equal [Liquid::InternalError], template.errors.map(&:class)
-  end
-
-  def test_setting_default_exception_renderer
-    old_exception_renderer = Liquid::Template.default_exception_renderer
-    exceptions = []
-    Liquid::Template.default_exception_renderer = ->(e) { exceptions << e; '' }
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')
-
-    output = template.render({ 'errors' => ErrorDrop.new })
-
-    assert_equal 'This is a runtime error: ', output
-    assert_equal [Liquid::ArgumentError], template.errors.map(&:class)
-  ensure
-    Liquid::Template.default_exception_renderer = old_exception_renderer if old_exception_renderer
-  end
-
-  def test_exception_renderer_exposing_non_liquid_error
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
-    exceptions = []
-    handler = ->(e) { exceptions << e; e.cause }
-
-    output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
-
-    assert_equal 'This is a runtime error: runtime error', output
-    assert_equal [Liquid::InternalError], exceptions.map(&:class)
-    assert_equal exceptions, template.errors
-    assert_equal '#<RuntimeError: runtime error>', exceptions.first.cause.inspect
-  end
-
-  class TestFileSystem
-    def read_template_file(template_path)
-      "{{ errors.argument_error }}"
-    end
-  end
-
-  def test_included_template_name_with_line_numbers
-    old_file_system = Liquid::Template.file_system
-
-    begin
-      Liquid::Template.file_system = TestFileSystem.new
-      template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
-      page = template.render('errors' => ErrorDrop.new)
-    ensure
-      Liquid::Template.file_system = old_file_system
-    end
-    assert_equal "Argument error:\nLiquid error (product line 1): argument error", page
-    assert_equal "product", template.errors.first.template_name
-  end
-end

test/integration/filter_test.rb

@@ -1,178 +0,0 @@
-require 'test_helper'
-
-module MoneyFilter
-  def money(input)
-    sprintf(' %d$ ', input)
-  end
-
-  def money_with_underscore(input)
-    sprintf(' %d$ ', input)
-  end
-end
-
-module CanadianMoneyFilter
-  def money(input)
-    sprintf(' %d$ CAD ', input)
-  end
-end
-
-module SubstituteFilter
-  def substitute(input, params = {})
-    input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
-  end
-end
-
-class FiltersTest < Minitest::Test
-  include Liquid
-
-  module OverrideObjectMethodFilter
-    def tap(input)
-      "tap overridden"
-    end
-  end
-
-  def setup
-    @context = Context.new
-  end
-
-  def test_local_filter
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-
-    assert_equal ' 1000$ ', Template.parse("{{var | money}}").render(@context)
-  end
-
-  def test_underscore_in_filter_name
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context)
-  end
-
-  def test_second_filter_overwrites_first
-    @context['var'] = 1000
-    @context.add_filters(MoneyFilter)
-    @context.add_filters(CanadianMoneyFilter)
-
-    assert_equal ' 1000$ CAD ', Template.parse("{{var | money}}").render(@context)
-  end
-
-  def test_size
-    @context['var'] = 'abcd'
-    @context.add_filters(MoneyFilter)
-
-    assert_equal '4', Template.parse("{{var | size}}").render(@context)
-  end
-
-  def test_join
-    @context['var'] = [1, 2, 3, 4]
-
-    assert_equal "1 2 3 4", Template.parse("{{var | join}}").render(@context)
-  end
-
-  def test_sort
-    @context['value'] = 3
-    @context['numbers'] = [2, 1, 4, 3]
-    @context['words'] = ['expected', 'as', 'alphabetic']
-    @context['arrays'] = ['flower', 'are']
-    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
-
-    assert_equal '1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context)
-    assert_equal 'alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context)
-    assert_equal '3', Template.parse("{{value | sort}}").render(@context)
-    assert_equal 'are flower', Template.parse("{{arrays | sort | join}}").render(@context)
-    assert_equal 'Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context)
-  end
-
-  def test_sort_natural
-    @context['words'] = ['case', 'Assert', 'Insensitive']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
-    @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
-
-    # Test strings
-    assert_equal 'Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context)
-
-    # Test hashes
-    assert_equal 'A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context)
-
-    # Test objects
-    assert_equal 'A b C', Template.parse("{{objects | sort_natural: 'a' | map: 'a' | join}}").render(@context)
-  end
-
-  def test_compact
-    @context['words'] = ['a', nil, 'b', nil, 'c']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
-    @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
-
-    # Test strings
-    assert_equal 'a b c', Template.parse("{{words | compact | join}}").render(@context)
-
-    # Test hashes
-    assert_equal 'A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context)
-
-    # Test objects
-    assert_equal 'A C', Template.parse("{{objects | compact: 'a' | map: 'a' | join}}").render(@context)
-  end
-
-  def test_strip_html
-    @context['var'] = "<b>bla blub</a>"
-
-    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
-  end
-
-  def test_strip_html_ignore_comments_with_html
-    @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
-
-    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
-  end
-
-  def test_capitalize
-    @context['var'] = "blub"
-
-    assert_equal "Blub", Template.parse("{{ var | capitalize }}").render(@context)
-  end
-
-  def test_nonexistent_filter_is_ignored
-    @context['var'] = 1000
-
-    assert_equal '1000', Template.parse("{{ var | xyzzy }}").render(@context)
-  end
-
-  def test_filter_with_keyword_arguments
-    @context['surname'] = 'john'
-    @context['input'] = 'hello %{first_name}, %{last_name}'
-    @context.add_filters(SubstituteFilter)
-    output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
-    assert_equal 'hello john, doe', output
-  end
-
-  def test_override_object_method_in_filter
-    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
-
-    # tap still treated as a non-existent filter
-    assert_equal "1000", Template.parse("{{var | tap}}").render!({ 'var' => 1000 })
-  end
-end
-
-class FiltersInTemplate < Minitest::Test
-  include Liquid
-
-  def test_local_global
-    with_global_filter(MoneyFilter) do
-      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: CanadianMoneyFilter)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: [CanadianMoneyFilter])
-    end
-  end
-
-  def test_local_filter_with_deprecated_syntax
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
-    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
-  end
-end # FiltersTest
-
-class TestObject < Liquid::Drop
-  attr_accessor :a
-  def initialize(a)
-    @a = a
-  end
-end