seperator -> separator

Add param to accept invalid input in to_integer

.gitignore

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

.rubocop.yml

@@ -0,0 +1,123 @@
+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/WordArray:
+  Enabled: false
+

.rubocop_todo.yml

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

@@ -6,7 +6,7 @@ rvm:
   - 2.2
   - ruby-head
   - jruby-head
-  - rbx-2
+#  - rbx-2
 
 sudo: false
 
@@ -14,7 +14,7 @@ matrix:
   allow_failures:
     - rvm: jruby-head
 
-script: "rake test"
+script: "bundle exec rake"
 
 notifications:
   disable: true

Gemfile

@@ -2,9 +2,13 @@ source 'https://rubygems.org'
 
 gemspec
 gem 'stackprof', platforms: :mri_21
-gem 'allocation_tracer', platforms: :mri_21
 
 group :test do
   gem 'spy', '0.4.1'
   gem 'benchmark-ips'
+  gem 'rubocop', '>=0.32.0'
+
+  platform :mri do
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '2570693d8d03faa0df9160ec74348a7149436df3'
+  end
 end

History.md

@@ -1,23 +1,38 @@
 # Liquid Change Log
 
 ## 4.0.0 / not yet released / branch "master"
+
 ### Changed
-* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li, pushrax]
-* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith, dylanahsmith]
-* Add concat filter to concatenate arrays (#429) [Diogo Beato, dvbeato]
-* Ruby 1.9 support dropped (#491) [Justin Li, pushrax]
-* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith, sunblaze]
+* Add compact filter (#600) [Carson Reinke]
+* Rename deprecated "has_key?" and "has_interrupt?" methods (#593) [Florian Weingarten]
+* Include template name with line numbers in render errors (574) [Dylan Thacker-Smith]
+* Add sort_natural filter (#554) [Martin Hanzel]
+* Add forloop.parentloop as a reference to the parent loop (#520) [Justin Li]
+* Block parsing moved to BlockBody class (#458) [Dylan Thacker-Smith]
+* Add concat filter to concatenate arrays (#429) [Diogo Beato]
+* Ruby 1.9 support dropped (#491) [Justin Li]
+* Liquid::Template.file_system's read_template_file method is no longer passed the context. (#441) [James Reid-Smith]
+* Remove support for `liquid_methods`
 
 ### Fixed
-* Fix capturing into variables with a hyphen in the name (#505) [Florian Weingarten, fw42]
-* Fix case sensitivity regression in date standard filter (#499) [Kelley Reynolds, kreynolds]
-* Disallow filters with no variable in strict mode (#475) [Justin Li, pushrax]
-* Disallow variable names in the strict parser that are not valid in the lax parser (#463) [Justin Li, pushrax]
-* Fix BlockBody#warnings taking exponential time to compute (#486) [Justin Li, pushrax]
+* 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.2 / 2015-04-24 / branch "3-0-stable"
+## 3.0.3 / 2015-05-28 / branch "3-0-stable"
 
-* Expose VariableLookup private members (#551) [Justin Li, pushrax]
+* 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
@@ -26,44 +41,44 @@
 
 ## 3.0.0 / 2014-11-12
 
-* Removed Block#end_tag. Instead, override parse with `super` followed by your code. See #446 [Dylan Thacker-Smith, dylanahsmith]
+* 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, djreimer]
-* Add uniq to standard filters [Florian Weingarten, fw42]
-* Add exception_handler feature (#397) and #254 [Bogdan Gusiev, bogdan and Florian Weingarten, fw42]
-* Optimize variable parsing to avoid repeated regex evaluation during template rendering #383 [Jason Hiltz-Laforge, jasonhl]
-* Optimize checking for block interrupts to reduce object allocation #380 [Jason Hiltz-Laforge, jasonhl] 
-* Properly set context rethrow_errors on render! #349 [Thierry Joyal, tjoyal]
-* Fix broken rendering of variables which are equal to false (#345) [Florian Weingarten, fw42]
-* Remove ActionView template handler [Dylan Thacker-Smith, dylanahsmith]
-* Freeze lots of string literals for new Ruby 2.1 optimization (#297) [Florian Weingarten, fw42]
-* Allow newlines in tags and variables (#324) [Dylan Thacker-Smith, dylanahsmith]
-* Tag#parse is called after initialize, which now takes options instead of tokens as the 3rd argument. See #321 [Dylan Thacker-Smith, dylanahsmith]
-* Raise `Liquid::ArgumentError` instead of `::ArgumentError` when filter has wrong number of arguments #309 [Bogdan Gusiev, bogdan]
-* Add a to_s default for liquid drops (#306) [Adam Doeler, releod]
-* Add strip, lstrip, and rstrip to standard filters [Florian Weingarten, fw42]
-* Make if, for & case tags return complete and consistent nodelists (#250) [Nick Jones, dntj]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Fix resource counting bug with respond_to?(:length) (#263) [Florian Weingarten, fw42]
-* Allow specifying custom patterns for template filenames (#284) [Andrei Gladkyi, agladkyi]
-* Allow drops to optimize loading a slice of elements (#282) [Tom Burns, boourns]
-* Support for passing variables to snippets in subdirs (#271) [Joost Hietbrink, joost]
-* Add a class cache to avoid runtime extend calls (#249) [James Tucker, raggi]
-* Remove some legacy Ruby 1.8 compatibility code (#276) [Florian Weingarten, fw42]
-* Add default filter to standard filters (#267) [Derrick Reimer, djreimer]
-* Add optional strict parsing and warn parsing (#235) [Tristan Hume, trishume]
+* 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, fw42]
-* Fix clashing method names in enumerable drops (#238) [Florian Weingarten, fw42]
-* Make map filter work on enumerable drops (#233) [Florian Weingarten, fw42]
-* Improved whitespace stripping for blank blocks, related to #216 [Florian Weingarten, fw42]
+* 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.1 / 2014-01-10 / branch "2-6-stable"
 
 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
+* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
+* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith]
 
 ## 2.6.0 / 2013-11-25
 
@@ -71,37 +86,37 @@ IMPORTANT: Liquid 2.6 is going to be the last version of Liquid which maintains
 The following releases will only be tested against Ruby 1.9 and Ruby 2.0 and are likely to break on Ruby 1.8.
 
 * Bugfix for #106: fix example servlet [gnowoel]
-* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss, joliss]
-* Bugfix for #114: strip_html filter supports style tags [James Allardice, jamesallardice]
-* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup, ndwebgroup]
-* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten, fw42]
-* Bugfix for #204: 'raw' parsing bug [Florian Weingarten, fw42]
-* Bugfix for #150: 'for' parsing bug [Peter Schröder, phoet]
-* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder, phoet]
-* Bugfix for #174, "can't convert Fixnum into String" for "replace" [wǒ_is神仙, jsw0528]
-* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep, darkhelmet]
-* Resource limits [Florian Weingarten, fw42]
-* Add reverse filter [Jay Strybis, unreal]
+* Bugfix for #97: strip_html filter supports multi-line tags [Jo Liss]
+* Bugfix for #114: strip_html filter supports style tags [James Allardice]
+* Bugfix for #117: 'now' support for date filter in Ruby 1.9 [Notre Dame Webgroup]
+* Bugfix for #166: truncate filter on UTF-8 strings with Ruby 1.8 [Florian Weingarten]
+* Bugfix for #204: 'raw' parsing bug [Florian Weingarten]
+* Bugfix for #150: 'for' parsing bug [Peter Schröder]
+* Bugfix for #126: Strip CRLF in strip_newline [Peter Schröder]
+* Bugfix for #174, "can't convert Fixnum into String" for "replace" [jsw0528]
+* Allow a Liquid::Drop to be passed into Template#render [Daniel Huckstep]
+* Resource limits [Florian Weingarten]
+* Add reverse filter [Jay Strybis]
 * Add utf-8 support
-* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos, astathopoulos]
-* Cache tokenized partial templates [Tom Burns, boourns]
-* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer, stomar]
-* Better documentation for 'include' tag (closes #163) [Peter Schröder, phoet]
-* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves, arthurnn]
+* Use array instead of Hash to keep the registered filters [Tasos Stathopoulos]
+* Cache tokenized partial templates [Tom Burns]
+* Avoid warnings in Ruby 1.9.3 [Marcus Stollsteimer]
+* Better documentation for 'include' tag (closes #163) [Peter Schröder]
+* Use of BigDecimal on filters to have better precision (closes #155) [Arthur Nogueira Neves]
 
 ## 2.5.5 / 2014-01-10 / branch "2-5-stable"
 
 Security fix, cherry-picked from master (4e14a65):
-* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl, bouk]
-* Prevent arbitrary method invocation on condition objects (#274) [Dylan Thacker-Smith, dylanahsmith]
+* Don't call to_sym when creating conditions for security reasons (#273) [Bouke van der Bijl]
+* 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), [wǒ_is神仙, jsw0528]
+* Fix "can't convert Fixnum into String" for "replace" (#173), [jsw0528]
 
 ## 2.5.3 / 2013-10-09
 
-* #232, #234, #237: Fix map filter bugs [Florian Weingarten, fw42]
+* #232, #234, #237: Fix map filter bugs [Florian Weingarten]
 
 ## 2.5.2 / 2013-09-03 / deleted
 
@@ -109,7 +124,7 @@ Yanked from rubygems, as it contained too many changes that broke compatibility.
 
 ## 2.5.1 / 2013-07-24
 
-* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten, fw42]
+* #230: Fix security issue with map filter, Use invoke_drop in map filter [Florian Weingarten]
 
 ## 2.5.0 / 2013-03-06
 

Rakefile

@@ -3,7 +3,7 @@ require 'rake/testtask'
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"
 
-task :default => 'test'
+task default: [:rubocop, :test]
 
 desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
@@ -18,25 +18,43 @@ 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"
@@ -44,7 +62,6 @@ task :release => :build do
 end
 
 namespace :benchmark do
-
   desc "Run the liquid benchmark with lax parsing"
   task :run do
     ruby "./performance/benchmark.rb lax"
@@ -56,9 +73,7 @@ namespace :benchmark do
   end
 end
 
-
 namespace :profile do
-
   desc "Run the liquid profile/performance coverage"
   task :run do
     ruby "./performance/profile.rb"
@@ -68,24 +83,13 @@ namespace :profile do
   task :strict do
     ruby "./performance/profile.rb strict"
   end
-
-end
-
-namespace :memory do
-
-  desc "Run the liquid memory tracer"
-  task :run do
-    ruby "./performance/memory.rb"
-  end
-
-  desc "Run the liquid memory tracer with strict parsing"
-  task :strict do
-    ruby "./performance/memory.rb strict"
-  end
-
 end
 
 desc "Run example"
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"
 end
+
+task :console do
+  exec 'irb -I lib -r liquid'
+end

circle.yml

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

example/server/example_servlet.rb

@@ -4,7 +4,7 @@ module ProductsFilter
   end
 
   def prettyprint(text)
-    text.gsub( /\*(.*)\*/, '<b>\1</b>' )
+    text.gsub(/\*(.*)\*/, '<b>\1</b>')
   end
 
   def count(array)
@@ -17,30 +17,28 @@ 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, 'more_products' => more_products_list, 'description' => description, 'section' => 'Snowboards', 'cool_products' => true }
   end
 
   private
 
   def products_list
-    [{'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
-    {'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling'},
-    {'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity'}]
+    [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+     { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
+     { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
   end
 
   def more_products_list
-    [{'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-    {'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape'}]
+    [{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
+     { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
   end
 
   def description
     "List of Products ~ This is a list of products with price and description."
   end
-
 end

example/server/liquid_servlet.rb

@@ -1,5 +1,4 @@
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
-
   def do_GET(req, res)
     handle(:get, req, res)
   end
@@ -20,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( File.dirname(__FILE__) + "/templates/#{filename}.liquid" )
+    File.read("#{__dir__}/templates/#{filename}.liquid")
   end
 end

example/server/server.rb

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

lib/liquid.rb

@@ -67,10 +67,10 @@ require 'liquid/resource_limits'
 require 'liquid/template'
 require 'liquid/standardfilters'
 require 'liquid/condition'
-require 'liquid/module_ex'
 require 'liquid/utils'
-require 'liquid/token'
+require 'liquid/tokenizer'
+require 'liquid/parse_context'
 
 # Load all the tags of the standard library
 #
-Dir[File.dirname(__FILE__) + '/liquid/tags/*.rb'].each { |f| require f }
+Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }

lib/liquid/block.rb

@@ -7,7 +7,7 @@ module Liquid
 
     def parse(tokens)
       @body = BlockBody.new
-      while more = parse_body(@body, tokens)
+      while parse_body(@body, tokens)
       end
     end
 
@@ -23,29 +23,17 @@ module Liquid
       @body.nodelist
     end
 
-    # warnings of this block and all sub-tags
-    def warnings
-      all_warnings = []
-      all_warnings.concat(@warnings) if @warnings
-
-      (nodelist || []).each do |node|
-        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
-      end
-
-      all_warnings
-    end
-
-    def unknown_tag(tag, params, tokens)
+    def unknown_tag(tag, _params, _tokens)
       case tag
       when 'else'.freeze
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_else".freeze,
-                                                 :block_name => block_name))
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze,
+          block_name: block_name))
       when 'end'.freeze
-        raise SyntaxError.new(options[:locale].t("errors.syntax.invalid_delimiter".freeze,
-                                                 :block_name => block_name,
-                                                 :block_delimiter => block_delimiter))
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
+          block_name: block_name,
+          block_delimiter: block_delimiter))
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
       end
     end
 
@@ -60,12 +48,12 @@ module Liquid
     protected
 
     def parse_body(body, tokens)
-      body.parse(tokens, options) do |end_tag_name, end_tag_params|
+      body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
         @blank &&= body.blank?
 
         return false if end_tag_name == block_delimiter
         unless end_tag_name
-          raise SyntaxError.new(@options[:locale].t("errors.syntax.tag_never_closed".freeze, :block_name => block_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

lib/liquid/block_body.rb

@@ -12,44 +12,37 @@ module Liquid
       @blank = true
     end
 
-    def parse(tokens, options)
-      while token = tokens.shift
-        begin
-          unless token.empty?
-            case
-            when token.start_with?(TAGSTART)
-              if token =~ FullToken
-                tag_name = $1
-                markup = $2
-                # fetch the tag from registered blocks
-                if tag = Template.tags[tag_name]
-                  markup = token.child(markup) if token.is_a?(Token)
-                  new_tag = tag.parse(tag_name, markup, tokens, options)
-                  new_tag.line_number = token.line_number if token.is_a?(Token)
-                  @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
+    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)
+            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
-                raise_missing_tag_terminator(token, options)
+                # end parsing if we reach an unknown tag and let the caller decide
+                # determine how to proceed
+                return yield tag_name, markup
               end
-            when token.start_with?(VARSTART)
-              new_var = create_variable(token, options)
-              new_var.line_number = token.line_number if token.is_a?(Token)
-              @nodelist << new_var
-              @blank = false
             else
-              @nodelist << token
-              @blank &&= !!(token =~ /\A\s*\z/)
+              raise_missing_tag_terminator(token, parse_context)
             end
+          when token.start_with?(VARSTART)
+            @nodelist << create_variable(token, parse_context)
+            @blank = false
+          else
+            @nodelist << token
+            @blank &&= !!(token =~ /\A\s*\z/)
           end
-        rescue SyntaxError => e
-          e.set_line_number_from_token(token)
-          raise
         end
+        parse_context.line_number = tokenizer.line_number
       end
 
       yield nil, nil
@@ -59,74 +52,69 @@ module Liquid
       @blank
     end
 
-    def warnings
-      all_warnings = []
-      nodelist.each do |node|
-        all_warnings.concat(node.warnings || []) if node.respond_to?(:warnings)
-      end
-      all_warnings
-    end
-
     def render(context)
-      @output ||= []
-      @output.clear
+      output = []
       context.resource_limits.render_score += @nodelist.length
 
       @nodelist.each do |token|
         # Break out if we have any unhanded interrupts.
-        break if context.has_interrupt?
+        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) or token.is_a?(Break)
+          if token.is_a?(Continue) || token.is_a?(Break)
             context.push_interrupt(token.interrupt)
             break
           end
 
-          token_output = render_token(token, context)
+          node_output = render_node(token, context)
 
           unless token.is_a?(Block) && token.blank?
-            @output << token_output
+            output << node_output
           end
         rescue MemoryError => e
           raise e
         rescue ::StandardError => e
-          @output << context.handle_error(e, token)
+          output << context.handle_error(e, token.line_number)
         end
       end
 
-      @output.join
+      output.join
     end
 
     private
 
-    def render_token(token, context)
-      token_output = (token.respond_to?(:render) ? token.render(context) : token)
-      token_str = token_output.is_a?(Array) ? token_output.join : token_output.to_s
+    def render_node(node, context)
+      node_output = (node.respond_to?(:render) ? node.render(context) : node)
+      node_output = node_output.is_a?(Array) ? node_output.join : node_output.to_s
 
-      context.resource_limits.render_length += token_str.length
+      context.resource_limits.render_length += node_output.length
       if context.resource_limits.reached?
         raise MemoryError.new("Memory limits exceeded".freeze)
       end
-      token_str
+      node_output
     end
 
-    def create_variable(token, options)
+    def create_variable(token, parse_context)
       token.scan(ContentOfVariable) do |content|
-        markup = token.is_a?(Token) ? token.child(content.first) : content.first
-        return Variable.new(markup, options)
+        markup = content.first
+        return Variable.new(markup, parse_context)
       end
-      raise_missing_variable_terminator(token, options)
+      raise_missing_variable_terminator(token, parse_context)
     end
 
-    def raise_missing_tag_terminator(token, options)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.tag_termination".freeze, :token => token, :tag_end => TagEnd.inspect))
+    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, options)
-      raise SyntaxError.new(options[:locale].t("errors.syntax.variable_termination".freeze, :token => token, :tag_end => VariableEnd.inspect))
+    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

@@ -8,16 +8,21 @@ module Liquid
   #
   class Condition #:nodoc:
     @@operators = {
-      '=='.freeze => lambda { |cond, left, right|  cond.send(:equal_variables, left, right) },
-      '!='.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
-      '<>'.freeze => lambda { |cond, left, right| !cond.send(:equal_variables, left, right) },
+      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
       '<'.freeze  => :<,
       '>'.freeze  => :>,
       '>='.freeze => :>=,
       '<='.freeze => :<=,
-      'contains'.freeze => lambda { |cond, left, right|
-        left && right && left.respond_to?(:include?) ? left.include?(right) : false
-      }
+      'contains'.freeze => lambda do |cond, left, right|
+        if left && right && left.respond_to?(:include?)
+          right = right.to_s if left.is_a?(String)
+          left.include?(right)
+        else
+          false
+        end
+      end
     }
 
     def self.operators
@@ -73,17 +78,17 @@ module Liquid
     private
 
     def equal_variables(left, right)
-      if left.is_a?(Symbol)
-        if right.respond_to?(left)
-          return right.send(left.to_s)
+      if left.is_a?(Liquid::Expression::MethodLiteral)
+        if right.respond_to?(left.method_name)
+          return right.send(left.method_name)
         else
           return nil
         end
       end
 
-      if right.is_a?(Symbol)
-        if left.respond_to?(right)
-          return left.send(right.to_s)
+      if right.is_a?(Liquid::Expression::MethodLiteral)
+        if left.respond_to?(right.method_name)
+          return left.send(right.method_name)
         else
           return nil
         end
@@ -96,7 +101,7 @@ module Liquid
       # If the operator is empty this means that the decision statement is just
       # a single variable. We can just poll this variable from the context and
       # return this as the result.
-      return context.evaluate(left) if op == nil
+      return context.evaluate(left) if op.nil?
 
       left = context.evaluate(left)
       right = context.evaluate(right)
@@ -105,27 +110,23 @@ module Liquid
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
-      elsif left.respond_to?(operation) and right.respond_to?(operation)
+      elsif left.respond_to?(operation) && right.respond_to?(operation)
         begin
           left.send(operation, right)
         rescue ::ArgumentError => e
           raise Liquid::ArgumentError.new(e.message)
         end
-      else
-        nil
       end
     end
   end
 
-
   class ElseCondition < Condition
     def else?
       true
     end
 
-    def evaluate(context)
+    def evaluate(_context)
       true
     end
   end
-
 end

lib/liquid/context.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Context keeps the variable stack and resolves variables, as well as keywords
   #
   #   context['variable'] = 'testing'
@@ -13,28 +12,30 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :registers, :environments, :resource_limits
-    attr_accessor :exception_handler
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_accessor :exception_handler, :template_name, :partial
 
     def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
       @environments     = [environments].flatten
       @scopes           = [(outer_scope || {})]
       @registers        = registers
+      @errors           = []
+      @partial          = false
       @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
       squash_instance_assigns_with_environments
 
       @this_stack_used = false
 
       if rethrow_errors
-        self.exception_handler = ->(e) { true }
+        self.exception_handler = ->(e) { raise }
       end
 
-      @interrupts = nil
+      @interrupts = []
       @filters = []
     end
 
-    def errors
-      @errors ||= []
+    def warnings
+      @warnings ||= []
     end
 
     def strainer
@@ -52,29 +53,45 @@ module Liquid
     end
 
     # are there any not handled interrupts?
-    def has_interrupt?
-      @interrupts && !@interrupts.empty?
+    def interrupt?
+      !@interrupts.empty?
     end
 
     # push an interrupt to the stack. this interrupt is considered not handled.
     def push_interrupt(e)
-      (@interrupts ||= []).push(e)
+      @interrupts.push(e)
     end
 
     # pop an interrupt from the stack
     def pop_interrupt
-      @interrupts.pop if @interrupts
+      @interrupts.pop
     end
 
-
-    def handle_error(e, token=nil)
+    def handle_error(e, line_number = nil)
       if e.is_a?(Liquid::Error)
-        e.set_line_number_from_token(token)
+        e.template_name ||= template_name
+        e.line_number ||= line_number
       end
 
+      output = nil
+
+      if exception_handler
+        result = exception_handler.call(e)
+        case result
+        when Exception
+          e = result
+          if e.is_a?(Liquid::Error)
+            e.template_name ||= template_name
+            e.line_number ||= line_number
+          end
+        when String
+          output = result
+        else
+          raise if result
+        end
+      end
       errors.push(e)
-      raise if exception_handler && exception_handler.call(e)
-      Liquid::Error.render(e)
+      output || Liquid::Error.render(e)
     end
 
     def invoke(method, *args)
@@ -82,7 +99,7 @@ module Liquid
     end
 
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
-    def push(new_scope={})
+    def push(new_scope = {})
       @scopes.unshift(new_scope)
       raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
     end
@@ -106,7 +123,7 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope=nil)
+    def stack(new_scope = nil)
       old_stack_used = @this_stack_used
       if new_scope
         push(new_scope)
@@ -146,7 +163,7 @@ module Liquid
       evaluate(Expression.parse(expression))
     end
 
-    def has_key?(key)
+    def key?(key)
       self[key] != nil
     end
 
@@ -156,10 +173,9 @@ module Liquid
 
     # Fetches an object starting at the local scope and then moving up the hierachy
     def find_variable(key)
-
       # This was changed from find() to find_index() because this is a very hot
       # path and find_index() is optimized in MRI to reduce object allocation
-      index = @scopes.find_index { |s| s.has_key?(key) }
+      index = @scopes.find_index { |s| s.key?(key) }
       scope = @scopes[index] if index
 
       variable = nil
@@ -174,13 +190,13 @@ module Liquid
         end
       end
 
-      scope     ||= @environments.last || @scopes.last
-      variable  ||= lookup_and_evaluate(scope, key)
+      scope ||= @environments.last || @scopes.last
+      variable ||= lookup_and_evaluate(scope, key)
 
       variable = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
-      return variable
+      variable
     end
 
     def lookup_and_evaluate(obj, key)
@@ -192,15 +208,16 @@ module Liquid
     end
 
     private
-      def squash_instance_assigns_with_environments
-        @scopes.last.each_key do |k|
-          @environments.each do |env|
-            if env.has_key?(k)
-              scopes.last[k] = lookup_and_evaluate(env, k)
-              break
-            end
+
+    def squash_instance_assigns_with_environments
+      @scopes.last.each_key do |k|
+        @environments.each do |env|
+          if env.key?(k)
+            scopes.last[k] = lookup_and_evaluate(env, k)
+            break
           end
         end
-      end # squash_instance_assigns_with_environments
+      end
+    end # squash_instance_assigns_with_environments
   end # Context
 end # Liquid

lib/liquid/document.rb

@@ -1,23 +1,26 @@
 module Liquid
   class Document < BlockBody
-    def self.parse(tokens, options)
+    def self.parse(tokens, parse_context)
       doc = new
-      doc.parse(tokens, options)
+      doc.parse(tokens, parse_context)
       doc
     end
 
-    def parse(tokens, options)
+    def parse(tokens, parse_context)
       super do |end_tag_name, end_tag_params|
-        unknown_tag(end_tag_name, options) if end_tag_name
+        unknown_tag(end_tag_name, parse_context) if end_tag_name
       end
+    rescue SyntaxError => e
+      e.line_number ||= parse_context.line_number
+      raise
     end
 
-    def unknown_tag(tag, options)
+    def unknown_tag(tag, parse_context)
       case tag
       when 'else'.freeze, 'end'.freeze
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unexpected_outer_tag".freeze, :tag => tag))
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag))
       else
-        raise SyntaxError.new(options[:locale].t("errors.syntax.unknown_tag".freeze, :tag => tag))
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
       end
     end
   end

lib/liquid/drop.rb

@@ -1,7 +1,6 @@
 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.
@@ -27,7 +26,7 @@ module Liquid
     EMPTY_STRING = ''.freeze
 
     # Catch all for the method
-    def before_method(method)
+    def before_method(_method)
       nil
     end
 
@@ -40,7 +39,7 @@ module Liquid
       end
     end
 
-    def has_key?(name)
+    def key?(_name)
       true
     end
 
@@ -56,13 +55,11 @@ module Liquid
       self.class.name
     end
 
-    alias :[] :invoke_drop
-
-    private
+    alias_method :[], :invoke_drop
 
     # Check for method existence without invoking respond_to?, which creates symbols
     def self.invokable?(method_name)
-      self.invokable_methods.include?(method_name.to_s)
+      invokable_methods.include?(method_name.to_s)
     end
 
     def self.invokable_methods

lib/liquid/errors.rb

@@ -1,9 +1,10 @@
 module Liquid
   class Error < ::StandardError
     attr_accessor :line_number
+    attr_accessor :template_name
     attr_accessor :markup_context
 
-    def to_s(with_prefix=true)
+    def to_s(with_prefix = true)
       str = ""
       str << message_prefix if with_prefix
       str << super()
@@ -16,17 +17,11 @@ module Liquid
       str
     end
 
-    def set_line_number_from_token(token)
-      return unless token.respond_to?(:line_number)
-      return if self.line_number
-      self.line_number = token.line_number
-    end
-
     def self.render(e)
       if e.is_a?(Liquid::Error)
         e.to_s
       else
-        "Liquid error: #{e.to_s}"
+        "Liquid error: #{e}"
       end
     end
 
@@ -41,7 +36,9 @@ module Liquid
       end
 
       if line_number
-        str << " (line #{line_number})"
+        str << " ("
+        str << template_name << " " if template_name
+        str << "line " << line_number.to_s << ")"
       end
 
       str << ": "
@@ -49,12 +46,14 @@ module Liquid
     end
   end
 
-  class ArgumentError < Error; end
-  class ContextError < Error; end
-  class FileSystemError < Error; end
-  class StandardError < Error; end
-  class SyntaxError < Error; end
-  class StackLevelError < Error; end
-  class TaintedError < Error; end
-  class MemoryError < Error; end
+  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)
 end

lib/liquid/expression.rb

@@ -1,11 +1,24 @@
 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 => :blank?,
-      'empty'.freeze => :empty?
+      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
+      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
     }
 
     def self.parse(markup)
@@ -28,6 +41,5 @@ module Liquid
         end
       end
     end
-
   end
 end

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)
       raise FileSystemError, "This liquid context does not allow includes."
     end
   end
@@ -51,7 +51,7 @@ module Liquid
 
     def read_template_file(template_path)
       full_path = full_path(template_path)
-      raise FileSystemError, "No such template '#{template_path}'" unless File.exists?(full_path)
+      raise FileSystemError, "No such template '#{template_path}'" unless File.exist?(full_path)
 
       File.read(full_path)
     end

lib/liquid/i18n.rb

@@ -2,10 +2,9 @@ require 'yaml'
 
 module Liquid
   class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(File.dirname(__FILE__)), "locales", "en.yml")
+    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
 
-    class TranslationError < StandardError
-    end
+    TranslationError = Class.new(StandardError)
 
     attr_reader :path
 
@@ -23,11 +22,12 @@ module Liquid
     end
 
     private
+
     def interpolate(name, vars)
-      name.gsub(/%\{(\w+)\}/) {
+      name.gsub(/%\{(\w+)\}/) do
         # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
         "#{vars[$1.to_sym]}"
-      }
+      end
     end
 
     def deep_fetch_translation(name)

lib/liquid/interrupts.rb

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

lib/liquid/lexer.rb

@@ -27,7 +27,7 @@ module Liquid
     def tokenize
       @output = []
 
-      while !@ss.eos?
+      until @ss.eos?
         @ss.skip(/\s*/)
         tok = case
         when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
@@ -39,7 +39,7 @@ module Liquid
         else
           c = @ss.getch
           if s = SPECIALS[c]
-            [s,c]
+            [s, c]
           else
             raise SyntaxError, "Unexpected character #{c}"
           end

lib/liquid/locales/en.yml

@@ -1,6 +1,7 @@
 ---
   errors:
     syntax:
+      tag_unexpected_args: "Syntax Error in '%{tag}' - Valid syntax: %{tag}"
       assign: "Syntax Error in 'assign' - Valid syntax: assign [var] = [source]"
       capture: "Syntax Error in 'capture' - Valid syntax: capture [var]"
       case: "Syntax Error in 'case' - Valid syntax: case [condition]"

lib/liquid/module_ex.rb

@@ -1,64 +0,0 @@
-# Copyright 2007 by Domizio Demichelis
-# This library is free software. It may be used, redistributed and/or modified
-# under the same terms as Ruby itself
-#
-# This extension is used in order to expose the object of the implementing class
-# to liquid as it were a Drop. It also limits the liquid-callable methods of the instance
-# to the allowed method passed with the liquid_methods call
-# Example:
-#
-#   class SomeClass
-#     liquid_methods :an_allowed_method
-#
-#     def an_allowed_method
-#       'this comes from an allowed method'
-#     end
-#
-#     def unallowed_method
-#       'this will never be an output'
-#     end
-#   end
-#
-# if you want to extend the drop to other methods you can defines more methods
-# in the class <YourClass>::LiquidDropClass
-#
-#   class SomeClass::LiquidDropClass
-#     def another_allowed_method
-#       'and this from another allowed method'
-#     end
-#   end
-#
-#
-# usage:
-#   @something = SomeClass.new
-#
-# template:
-#   {{something.an_allowed_method}}{{something.unallowed_method}} {{something.another_allowed_method}}
-#
-# output:
-#   'this comes from an allowed method and this from another allowed method'
-#
-# You can also chain associations, by adding the liquid_method call in the
-# association models.
-#
-class Module
-  def liquid_methods(*allowed_methods)
-    drop_class = eval "class #{self.to_s}::LiquidDropClass < Liquid::Drop; self; end"
-    
-    define_method :to_liquid do
-      drop_class.new(self)
-    end
-    
-    drop_class.class_eval do
-      def initialize(object)
-        @object = object
-      end
-      
-      allowed_methods.each do |sym|
-        define_method sym do
-          @object.send sym
-        end
-      end
-    end
-  end
-end

lib/liquid/parse_context.rb

@@ -0,0 +1,37 @@
+module Liquid
+  class ParseContext
+    attr_accessor :partial, :locale, :line_number
+    attr_reader :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_switching.rb

@@ -1,25 +1,25 @@
 module Liquid
   module ParserSwitching
     def parse_with_selected_parser(markup)
-      case @options[:error_mode] || Template.error_mode
+      case parse_context.error_mode
       when :strict then strict_parse_with_error_context(markup)
-      when :lax    then lax_parse(markup)
+      when :lax, :lax_warn then lax_parse(markup)
       when :warn
         begin
           return strict_parse_with_error_context(markup)
         rescue SyntaxError => e
-          e.set_line_number_from_token(markup)
-          @warnings ||= []
-          @warnings << 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

lib/liquid/profiler.rb

@@ -1,7 +1,6 @@
 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'.
@@ -20,7 +19,7 @@ module Liquid
   # inside of <tt>{% include %}</tt> tags.
   #
   #   profile.each do |node|
-  #     # Access to the token itself
+  #     # Access to the node itself
   #     node.code
   #
   #     # Which template and line number of this node.
@@ -47,17 +46,15 @@ module Liquid
     class Timing
       attr_reader :code, :partial, :line_number, :children
 
-      def initialize(token, partial)
-        @code        = token.respond_to?(:raw) ? token.raw : token
+      def initialize(node, partial)
+        @code        = node.respond_to?(:raw) ? node.raw : node
         @partial     = partial
-        @line_number = token.respond_to?(:line_number) ? token.line_number : nil
+        @line_number = node.respond_to?(:line_number) ? node.line_number : nil
         @children    = []
       end
 
-      def self.start(token, partial)
-        new(token, partial).tap do |t|
-          t.start
-        end
+      def self.start(node, partial)
+        new(node, partial).tap(&:start)
       end
 
       def start
@@ -73,11 +70,11 @@ module Liquid
       end
     end
 
-    def self.profile_token_render(token)
-      if Profiler.current_profile && token.respond_to?(:render)
-        Profiler.current_profile.start_token(token)
+    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_token(token)
+        Profiler.current_profile.end_node(node)
         output
       else
         yield
@@ -135,11 +132,11 @@ module Liquid
       @root_timing.children.length
     end
 
-    def start_token(token)
-      @timing_stack.push(Timing.start(token, current_partial))
+    def start_node(node)
+      @timing_stack.push(Timing.start(node, current_partial))
     end
 
-    def end_token(token)
+    def end_node(_node)
       timing = @timing_stack.pop
       timing.finish
 
@@ -157,6 +154,5 @@ module Liquid
     def pop_partial
       @partial_stack.pop
     end
-
   end
 end

lib/liquid/profiler/hooks.rb

@@ -1,18 +1,18 @@
 module Liquid
   class BlockBody
-    def render_token_with_profiling(token, context)
-      Profiler.profile_token_render(token) do
-        render_token_without_profiling(token, context)
+    def render_node_with_profiling(node, context)
+      Profiler.profile_node_render(node) do
+        render_node_without_profiling(node, context)
       end
     end
 
-    alias_method :render_token_without_profiling, :render_token
-    alias_method :render_token, :render_token_with_profiling
+    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).to_s) do
+      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
         render_without_profiling(context)
       end
     end

lib/liquid/range_lookup.rb

@@ -16,7 +16,22 @@ module Liquid
     end
 
     def evaluate(context)
-      context.evaluate(@start_obj).to_i..context.evaluate(@end_obj).to_i
+      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,7 +1,7 @@
 module Liquid
   class ResourceLimits
     attr_accessor :render_length, :render_score, :assign_score,
-                  :render_length_limit, :render_score_limit, :assign_score_limit
+      :render_length_limit, :render_score_limit, :assign_score_limit
 
     def initialize(limits)
       @render_length_limit = limits[:render_length_limit]
@@ -12,8 +12,8 @@ module Liquid
 
     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 )
+        (@render_score_limit && @render_score > @render_score_limit) ||
+        (@assign_score_limit && @assign_score > @assign_score_limit)
     end
 
     def reset

lib/liquid/standardfilters.rb

@@ -2,7 +2,6 @@ require 'cgi'
 require 'bigdecimal'
 
 module Liquid
-
   module StandardFilters
     HTML_ESCAPE = {
       '&'.freeze => '&'.freeze,
@@ -34,7 +33,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input).untaint rescue input
+      CGI.escapeHTML(input).untaint
     end
     alias_method :h, :escape
 
@@ -46,9 +45,9 @@ module Liquid
       CGI.escape(input) rescue input
     end
 
-    def slice(input, offset, length=nil)
-      offset = Integer(offset)
-      length = length ? Integer(length) : 1
+    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) || []
@@ -59,16 +58,18 @@ module Liquid
 
     # Truncate a string down to x characters
     def truncate(input, length = 50, truncate_string = "...".freeze)
-      if input.nil? then return end
-      l = length.to_i - truncate_string.length
+      return if input.nil?
+      length = Utils.to_integer(length)
+      l = length - truncate_string.length
       l = 0 if l < 0
-      input.length > length.to_i ? input[0...l] + truncate_string : input
+      input.length > length ? input[0...l] + truncate_string : input
     end
 
     def truncatewords(input, words = 15, truncate_string = "...".freeze)
-      if input.nil? then return end
+      return if input.nil?
       wordlist = input.to_s.split
-      l = words.to_i - 1
+      words = Utils.to_integer(words)
+      l = words - 1
       l = 0 if l < 0
       wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string : input
     end
@@ -116,9 +117,23 @@ module Liquid
       if property.nil?
         ary.sort
       elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        ary.sort {|a,b| a[property] <=> b[property] }
+        ary.sort { |a, b| a[property] <=> b[property] }
       elsif ary.first.respond_to?(property)
-        ary.sort {|a,b| a.send(property) <=> b.send(property) }
+        ary.sort { |a, b| a.send(property) <=> b.send(property) }
+      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.first.respond_to?(:[]) && !ary.first[property].nil?
+        ary.sort { |a, b| a[property].casecmp(b[property]) }
+      elsif ary.first.respond_to?(property)
+        ary.sort { |a, b| a.send(property).casecmp(b.send(property)) }
       end
     end
 
@@ -126,10 +141,11 @@ module Liquid
     # provide optional property with which to determine uniqueness
     def uniq(input, property = nil)
       ary = InputIterator.new(input)
+
       if property.nil?
-        input.uniq
-      elsif input.first.respond_to?(:[])
-        input.uniq{ |a| a[property] }
+        ary.uniq
+      elsif ary.first.respond_to?(:[])
+        ary.uniq{ |a| a[property] }
       end
     end
 
@@ -152,24 +168,38 @@ module Liquid
       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.first.respond_to?(:[])
+        ary.reject{ |a| a[property].nil? }
+      elsif ary.first.respond_to?(property)
+        ary.reject { |a| a.send(property).nil? }
+      end
+    end
+
     # Replace occurrences of a string with another
     def replace(input, string, replacement = ''.freeze)
-      input.to_s.gsub(string, replacement.to_s)
+      input.to_s.gsub(string.to_s, replacement.to_s)
     end
 
     # Replace the first occurrences of a string with another
     def replace_first(input, string, replacement = ''.freeze)
-      input.to_s.sub(string, replacement.to_s)
+      input.to_s.sub(string.to_s, replacement.to_s)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string, ''.freeze)
+      input.to_s.gsub(string.to_s, ''.freeze)
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string, ''.freeze)
+      input.to_s.sub(string.to_s, ''.freeze)
     end
 
     # add one string to another
@@ -225,7 +255,7 @@ module Liquid
     def date(input, format)
       return input if format.to_s.empty?
 
-      return input unless date = to_date(input)
+      return input unless date = Utils.to_date(input)
 
       date.strftime(format.to_s)
     end
@@ -266,25 +296,35 @@ module Liquid
     # division
     def divided_by(input, operand)
       apply_operation(input, operand, :/)
+    rescue ::ZeroDivisionError => e
+      raise Liquid::ZeroDivisionError, e.message
     end
 
     def modulo(input, operand)
       apply_operation(input, operand, :%)
+    rescue ::ZeroDivisionError => e
+      raise Liquid::ZeroDivisionError, e.message
     end
 
     def round(input, n = 0)
-      result = to_number(input).round(to_number(n))
+      result = Utils.to_number(input).round(Utils.to_number(n))
       result = result.to_f if result.is_a?(BigDecimal)
       result = result.to_i if n == 0
       result
+    rescue ::FloatDomainError => e
+      raise Liquid::FloatDomainError, e.message
     end
 
     def ceil(input)
-      to_number(input).ceil.to_i
+      Utils.to_number(input).ceil.to_i
+    rescue ::FloatDomainError => e
+      raise Liquid::FloatDomainError, e.message
     end
 
     def floor(input)
-      to_number(input).floor.to_i
+      Utils.to_number(input).floor.to_i
+    rescue ::FloatDomainError => e
+      raise Liquid::FloatDomainError, e.message
     end
 
     def default(input, default_value = "".freeze)
@@ -294,40 +334,8 @@ module Liquid
 
     private
 
-    def to_number(obj)
-      case obj
-      when Float
-        BigDecimal.new(obj.to_s)
-      when Numeric
-        obj
-      when String
-        (obj.strip =~ /\A\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
-      else
-        0
-      end
-    end
-
-    def to_date(obj)
-      return obj if obj.respond_to?(:strftime)
-
-      obj = obj.downcase if obj.is_a?(String)
-
-      case obj
-      when 'now'.freeze, 'today'.freeze
-        Time.now
-      when /\A\d+\z/, Integer
-        Time.at(obj.to_i)
-      when String
-        Time.parse(obj)
-      else
-        nil
-      end
-    rescue ArgumentError
-      nil
-    end
-
     def apply_operation(input, operand, operation)
-      result = to_number(input).send(operation, to_number(operand))
+      result = Utils.to_number(input).send(operation, Utils.to_number(operand))
       result.is_a?(BigDecimal) ? result.to_f : result
     end
 
@@ -358,6 +366,14 @@ module Liquid
         reverse_each.to_a
       end
 
+      def uniq(&block)
+        to_a.uniq(&block)
+      end
+
+      def compact
+        to_a.compact
+      end
+
       def each
         @input.each do |e|
           yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)

lib/liquid/strainer.rb

@@ -1,7 +1,6 @@
 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.
   #
@@ -22,14 +21,14 @@ module Liquid
       @context = context
     end
 
-    def self.filter_methods
-      @filter_methods
+    class << self
+      attr_reader :filter_methods
     end
 
     def self.add_filter(filter)
       raise ArgumentError, "Expected module but got: #{f.class}" unless filter.is_a?(Module)
       unless self.class.include?(filter)
-        self.send(:include, filter)
+        send(:include, filter)
         @filter_methods.merge(filter.public_instance_methods.map(&:to_s))
       end
     end

lib/liquid/tag.rb

@@ -1,26 +1,27 @@
 module Liquid
   class Tag
-    attr_accessor :options, :line_number
-    attr_reader :nodelist, :warnings
+    attr_reader :nodelist, :tag_name, :line_number, :parse_context
+    alias_method :options, :parse_context
     include ParserSwitching
 
     class << self
-      def parse(tag_name, markup, tokens, options)
+      def parse(tag_name, markup, tokenizer, options)
         tag = new(tag_name, markup, options)
-        tag.parse(tokens)
+        tag.parse(tokenizer)
         tag
       end
 
       private :new
     end
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, parse_context)
       @tag_name   = tag_name
       @markup     = markup
-      @options    = options
+      @parse_context = parse_context
+      @line_number = parse_context.line_number
     end
 
-    def parse(tokens)
+    def parse(_tokens)
     end
 
     def raw
@@ -31,7 +32,7 @@ module Liquid
       self.class.name.downcase
     end
 
-    def render(context)
+    def render(_context)
       ''.freeze
     end
 

lib/liquid/tags/assign.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Assign sets a variable in your template.
   #
   #   {% assign foo = 'monkey' %}
@@ -15,8 +14,7 @@ module Liquid
       super
       if markup =~ Syntax
         @to = $1
-        @from = Variable.new($2,options)
-        @from.line_number = line_number
+        @from = Variable.new($2, options)
       else
         raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
       end

lib/liquid/tags/break.rb

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

lib/liquid/tags/case.rb

@@ -16,7 +16,7 @@ module Liquid
 
     def parse(tokens)
       body = BlockBody.new
-      while more = parse_body(body, tokens)
+      while parse_body(body, tokens)
         body = @blocks.last.attachment
       end
     end
@@ -59,7 +59,7 @@ module Liquid
       body = BlockBody.new
 
       while markup
-        if not markup =~ WhenSyntax
+        unless markup =~ WhenSyntax
           raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
         end
 
@@ -72,7 +72,7 @@ module Liquid
     end
 
     def record_else_condition(markup)
-      if not markup.strip.empty?
+      unless markup.strip.empty?
         raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
       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?

lib/liquid/tags/decrement.rb

@@ -1,5 +1,4 @@
 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.
@@ -26,12 +25,10 @@ module Liquid
 
     def render(context)
       value = context.environments.first[@variable] ||= 0
-      value = value - 1
+      value -= 1
       context.environments.first[@variable] = value
       value.to_s
     end
-
-    private
   end
 
   Template.register_tag('decrement'.freeze, Decrement)

lib/liquid/tags/for.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # "For" iterates over an array or collection.
   # Several useful variables are available to you within the loop.
   #
@@ -54,9 +53,8 @@ module Liquid
     end
 
     def parse(tokens)
-      if more = parse_body(@for_block, tokens)
-        parse_body(@else_block, tokens)
-      end
+      return unless parse_body(@for_block, tokens)
+      parse_body(@else_block, tokens)
     end
 
     def nodelist
@@ -69,16 +67,17 @@ module Liquid
     end
 
     def render(context)
-      context.registers[:for] ||= Hash.new(0)
+      for_offsets = context.registers[:for] ||= Hash.new(0)
+      for_stack = context.registers[:for_stack] ||= []
+
+      parent_loop = for_stack.last
+      for_stack.push(nil)
 
       collection = context.evaluate(@collection_name)
       collection = collection.to_a if collection.is_a?(Range)
 
-      # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      return render_else(context) unless iterable?(collection)
-
       from = if @from == :continue
-        context.registers[:for][@name].to_i
+        for_offsets[@name].to_i
       else
         context.evaluate(@from).to_i
       end
@@ -97,14 +96,12 @@ module Liquid
       length = segment.length
 
       # Store our progress through the collection for the continue flag
-      context.registers[:for][@name] = from + segment.length
-
-      parent_loop = context['forloop'.freeze]
+      for_offsets[@name] = from + segment.length
 
       context.stack do
         segment.each_with_index do |item, index|
           context[@variable_name] = item
-          context['forloop'.freeze] = {
+          loop_vars = {
             'name'.freeze       => @name,
             'length'.freeze     => length,
             'index'.freeze      => index + 1,
@@ -116,17 +113,23 @@ module Liquid
             'parentloop'.freeze => parent_loop
           }
 
+          context['forloop'.freeze] = loop_vars
+          for_stack[-1] = loop_vars
+
           result << @for_block.render(context)
 
           # Handle any interrupts if they exist.
-          if context.has_interrupt?
+          if context.interrupt?
             interrupt = context.pop_interrupt
             break if interrupt.is_a? BreakInterrupt
             next if interrupt.is_a? ContinueInterrupt
           end
         end
       end
+
       result
+    ensure
+      for_stack.pop
     end
 
     protected
@@ -135,7 +138,7 @@ module Liquid
       if markup =~ Syntax
         @variable_name = $1
         collection_name = $2
-        @reversed = $3
+        @reversed = !!$3
         @name = "#{@variable_name}-#{collection_name}"
         @collection_name = Expression.parse(collection_name)
         markup.scan(TagAttributes) do |key, value|
@@ -183,10 +186,6 @@ module Liquid
     def render_else(context)
       @else_block ? @else_block.render(context) : ''.freeze
     end
-
-    def iterable?(collection)
-      collection.respond_to?(:each) || Utils.non_blank_string?(collection)
-    end
   end
 
   Template.register_tag('for'.freeze, For)

lib/liquid/tags/if.rb

@@ -21,7 +21,7 @@ module Liquid
     end
 
     def parse(tokens)
-      while more = parse_body(@blocks.last.attachment, tokens)
+      while parse_body(@blocks.last.attachment, tokens)
       end
     end
 
@@ -50,61 +50,61 @@ module Liquid
 
     private
 
-      def push_block(tag, markup)
-        block = if tag == 'else'.freeze
-          ElseCondition.new
-        else
-          parse_with_selected_parser(markup)
-        end
-
-        @blocks.push(block)
-        block.attach(BlockBody.new)
+    def push_block(tag, markup)
+      block = if tag == 'else'.freeze
+        ElseCondition.new
+      else
+        parse_with_selected_parser(markup)
       end
 
-      def lax_parse(markup)
-        expressions = markup.scan(ExpressionsAndOperators)
-        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
+      @blocks.push(block)
+      block.attach(BlockBody.new)
+    end
 
-        condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+    def lax_parse(markup)
+      expressions = markup.scan(ExpressionsAndOperators)
+      raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
 
-        while not expressions.empty?
-          operator = expressions.pop.to_s.strip
+      condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
 
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
+      until expressions.empty?
+        operator = expressions.pop.to_s.strip
 
-          new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
-          raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
-          new_condition.send(operator, condition)
-          condition = new_condition
-        end
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
 
-        condition
+        new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
+        new_condition.send(operator, condition)
+        condition = new_condition
       end
 
-      def strict_parse(markup)
-        p = Parser.new(markup)
+      condition
+    end
 
-        condition = parse_comparison(p)
+    def strict_parse(markup)
+      p = Parser.new(markup)
+      condition = parse_binary_comparison(p)
+      p.consume(:end_of_string)
+      condition
+    end
 
-        while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
-          new_cond = parse_comparison(p)
-          new_cond.send(op, condition)
-          condition = new_cond
-        end
-        p.consume(:end_of_string)
-
-        condition
+    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))
       end
+      condition
+    end
 
-      def parse_comparison(p)
-        a = Expression.parse(p.expression)
-        if op = p.consume?(:comparison)
-          b = Expression.parse(p.expression)
-          Condition.new(a, op, b)
-        else
-          Condition.new(a)
-        end
+    def parse_comparison(p)
+      a = Expression.parse(p.expression)
+      if op = p.consume?(:comparison)
+        b = Expression.parse(p.expression)
+        Condition.new(a, op, b)
+      else
+        Condition.new(a)
       end
+    end
   end
 
   Template.register_tag('if'.freeze, If)

lib/liquid/tags/ifchanged.rb

@@ -1,9 +1,7 @@
 module Liquid
   class Ifchanged < Block
-
     def render(context)
       context.stack do
-
         output = super
 
         if output != context.registers[:ifchanged]

lib/liquid/tags/include.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Include allows templates to relate with other templates
   #
   # Simply include another template:
@@ -25,10 +24,9 @@ module Liquid
         template_name = $1
         variable_name = $3
 
-        @variable_name = Expression.parse(variable_name || template_name[1..-2])
-        @context_variable_name = template_name[1..-2].split('/'.freeze).last
-        @template_name = Expression.parse(template_name)
-        @attributes    = {}
+        @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)
@@ -39,60 +37,75 @@ module Liquid
       end
     end
 
-    def parse(tokens)
+    def parse(_tokens)
     end
 
     def render(context)
-      partial = load_cached_partial(context)
-      variable = context.evaluate(@variable_name)
+      template_name = context.evaluate(@template_name_expr)
+      partial = load_cached_partial(template_name, context)
 
-      context.stack do
-        @attributes.each do |key, value|
-          context[key] = context.evaluate(value)
-        end
+      context_variable_name = template_name.split('/'.freeze).last
 
-        if variable.is_a?(Array)
-          variable.collect do |var|
-            context[@context_variable_name] = var
+      variable = if @variable_name_expr
+        context.evaluate(@variable_name_expr)
+      else
+        context.find_variable(template_name)
+      end
+
+      old_template_name = context.template_name
+      old_partial = context.partial
+      begin
+        context.template_name = template_name
+        context.partial = true
+        context.stack do
+          @attributes.each do |key, value|
+            context[key] = context.evaluate(value)
+          end
+
+          if variable.is_a?(Array)
+            variable.collect do |var|
+              context[context_variable_name] = var
+              partial.render(context)
+            end
+          else
+            context[context_variable_name] = variable
             partial.render(context)
           end
-        else
-          context[@context_variable_name] = variable
-          partial.render(context)
         end
+      ensure
+        context.template_name = old_template_name
+        context.partial = old_partial
       end
     end
 
     private
-      def load_cached_partial(context)
-        cached_partials = context.registers[:cached_partials] || {}
-        template_name = context.evaluate(@template_name)
 
-        if cached = cached_partials[template_name]
-          return cached
-        end
-        source = read_template_from_file_system(context)
-        partial = Liquid::Template.parse(source, pass_options)
-        cached_partials[template_name] = partial
-        context.registers[:cached_partials] = cached_partials
-        partial
+    alias_method :parse_context, :options
+    private :parse_context
+
+    def load_cached_partial(template_name, context)
+      cached_partials = context.registers[:cached_partials] || {}
+
+      if cached = cached_partials[template_name]
+        return cached
       end
-
-      def read_template_from_file_system(context)
-        file_system = context.registers[:file_system] || Liquid::Template.file_system
-
-        file_system.read_template_file(context.evaluate(@template_name))
+      source = read_template_from_file_system(context)
+      begin
+        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
+    end
 
-      def pass_options
-        dont_pass = @options[:include_options_blacklist]
-        return {locale: @options[:locale]} if dont_pass == true
-        opts = @options.merge(included: true, include_options_blacklist: false)
-        if dont_pass.is_a?(Array)
-          dont_pass.each {|o| opts.delete(o)}
-        end
-        opts
-      end
+    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))
+    end
   end
 
   Template.register_tag('include'.freeze, Include)

lib/liquid/tags/raw.rb

@@ -1,7 +1,16 @@
 module Liquid
   class Raw < Block
+    Syntax = /\A\s*\z/
     FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
 
+    def initialize(tag_name, markup, parse_context)
+      super
+
+      unless markup =~ Syntax
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name))
+      end
+    end
+
     def parse(tokens)
       @body = ''
       while token = tokens.shift
@@ -9,11 +18,13 @@ module Liquid
           @body << $1 if $1 != "".freeze
           return if block_delimiter == $2
         end
-        @body << token if not token.empty?
+        @body << token unless token.empty?
       end
+
+      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
     end
 
-    def render(context)
+    def render(_context)
       @body
     end
 

lib/liquid/tags/table_row.rb

@@ -33,7 +33,6 @@ module Liquid
 
       result = "<tr class=\"row1\">\n"
       context.stack do
-
         collection.each_with_index do |item, index|
           context[@variable_name] = item
           context['tablerowloop'.freeze] = {
@@ -50,17 +49,15 @@ module Liquid
             'col_last'.freeze  => (col == cols - 1)
           }
 
-
           col += 1
 
           result << "<td class=\"col#{col}\">" << super << '</td>'
 
-          if col == cols and (index != length - 1)
+          if col == cols && (index != length - 1)
             col  = 0
             row += 1
             result << "</tr>\n<tr class=\"row#{row}\">"
           end
-
         end
       end
       result << "</tr>\n"

lib/liquid/tags/unless.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/if'
+require_relative 'if'
 
 module Liquid
   # Unless is a conditional just like 'if' but works on the inverse logic.
@@ -8,7 +8,6 @@ module Liquid
   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)

lib/liquid/template.rb

@@ -1,5 +1,4 @@
 module Liquid
-
   # Templates are central to liquid.
   # Interpretating templates is a two step process. First you compile the
   # source code you got. During compile time some extensive error checking is performed.
@@ -14,12 +13,8 @@ module Liquid
   #   template.render('user_name' => 'bob')
   #
   class Template
-    DEFAULT_OPTIONS = {
-      :locale => I18n.new
-    }
-
     attr_accessor :root
-    attr_reader :resource_limits
+    attr_reader :resource_limits, :warnings
 
     @@file_system = BlankFileSystem.new
 
@@ -30,7 +25,7 @@ module Liquid
       end
 
       def [](tag_name)
-        return nil unless @tags.has_key?(tag_name)
+        return nil unless @tags.key?(tag_name)
         return @cache[tag_name] if Liquid.cache_classes
 
         lookup_class(@tags[tag_name]).tap { |o| @cache[tag_name] = o }
@@ -121,16 +116,12 @@ module Liquid
       @options = options
       @profiling = options[:profile]
       @line_numbers = options[:line_numbers] || @profiling
-      @root = Document.parse(tokenize(source), DEFAULT_OPTIONS.merge(options))
-      @warnings = nil
+      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
@@ -169,7 +160,7 @@ module Liquid
         c = args.shift
 
         if @rethrow_errors
-          c.exception_handler = ->(e) { true }
+          c.exception_handler = ->(e) { raise }
         end
 
         c
@@ -189,7 +180,7 @@ module Liquid
         options = args.pop
 
         if options[:registers].is_a?(Hash)
-          self.registers.merge!(options[:registers])
+          registers.merge!(options[:registers])
         end
 
         if options[:filters]
@@ -211,7 +202,7 @@ module Liquid
       begin
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
-        result = with_profiling do
+        result = with_profiling(context) do
           @root.render(context)
         end
         result.respond_to?(:join) ? result.join : result
@@ -229,32 +220,12 @@ module Liquid
 
     private
 
-    # Uses the <tt>Liquid::TemplateParser</tt> regexp to tokenize the passed source
     def tokenize(source)
-      source = source.source if source.respond_to?(:source)
-      return [] if source.to_s.empty?
-
-      tokens = calculate_line_numbers(source.split(TemplateParser))
-
-      # removes the rogue empty element at the beginning of the array
-      tokens.shift if tokens[0] and tokens[0].empty?
-
-      tokens
+      Tokenizer.new(source, @line_numbers)
     end
 
-    def calculate_line_numbers(raw_tokens)
-      return raw_tokens unless @line_numbers
-
-      current_line = 1
-      raw_tokens.map do |token|
-        Token.new(token, current_line).tap do
-          current_line += token.count("\n")
-        end
-      end
-    end
-
-    def with_profiling
-      if @profiling && !@options[:included]
+    def with_profiling(context)
+      if @profiling && !context.partial
         raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
 
         @profiler = Profiler.new

lib/liquid/token.rb

@@ -1,18 +0,0 @@
-module Liquid
-  class Token < String
-    attr_reader :line_number
-
-    def initialize(content, line_number)
-      super(content)
-      @line_number = line_number
-    end
-
-    def raw
-      "<raw>"
-    end
-
-    def child(string)
-      Token.new(string, @line_number)
-    end
-  end
-end

lib/liquid/tokenizer.rb

@@ -0,0 +1,31 @@
+module Liquid
+  class Tokenizer
+    attr_reader :line_number
+
+    def initialize(source, line_numbers = false)
+      @source = source
+      @line_number = 1 if line_numbers
+      @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,27 +1,24 @@
 module Liquid
   module Utils
-
     def self.slice_collection(collection, from, to)
-      if (from != 0 || to != nil) && collection.respond_to?(:load_slice)
+      if (from != 0 || !to.nil?) && collection.respond_to?(:load_slice)
         collection.load_slice(from, to)
       else
         slice_collection_using_each(collection, from, to)
       end
     end
 
-    def self.non_blank_string?(collection)
-      collection.is_a?(String) && collection != ''.freeze
-    end
-
     def self.slice_collection_using_each(collection, from, to)
       segments = []
       index = 0
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
-      return [collection] if non_blank_string?(collection)
+      if collection.is_a?(String)
+        return collection.empty? ? [] : [collection]
+      end
+      return [] unless collection.respond_to?(:each)
 
       collection.each do |item|
-
         if to && to <= index
           break
         end
@@ -35,5 +32,48 @@ 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
+        0
+      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,5 +1,4 @@
 module Liquid
-
   # Holds variables. Variables are only loaded "just in time"
   # and are not evaluated as part of the render stage
   #
@@ -11,15 +10,26 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    attr_accessor :filters, :name, :warnings
-    attr_accessor :line_number
+    capture_ignored_variable_prefix = /([\s,\|'"]+?)??/
+    capture_expression = /(#{QuotedFragment})/o
+    capture_ignored_filter_prefix = /([^\|]+?)??/
+    capture_filters = /(#{FilterSeparator}.*)/o
+    VariableSyntax = /\A\s*#{capture_ignored_variable_prefix}\s*#{capture_expression}\s*(?:#{capture_ignored_filter_prefix}\s*#{capture_filters})?\z/om
+
+    capture_lax_separator = /(['"\|]+?)/
+    capture_filter = /((?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+)/o
+    FilterParser = /\s*(?:#{FilterSeparator}|#{capture_lax_separator})\s*#{capture_filter}/o
+
+    attr_accessor :filters, :name, :line_number
+    attr_reader :parse_context
+    alias_method :options, :parse_context
     include ParserSwitching
 
-    def initialize(markup, options = {})
+    def initialize(markup, parse_context)
       @markup  = markup
       @name    = nil
-      @options = options || {}
+      @parse_context = parse_context
+      @line_number = parse_context.line_number
 
       parse_with_selected_parser(markup)
     end
@@ -33,28 +43,28 @@ module Liquid
     end
 
     def lax_parse(markup)
-      @filters ||= []
-      @filters.clear
-      if markup =~ /(#{QuotedFragment})(.*)/om
-        name_markup = $1
-        filter_markup = $2
-        @name = Expression.parse(name_markup)
-        if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
-          filters = $1.scan(FilterParser)
-          filters.each do |f|
-            if f =~ /\w+/
-              filtername = Regexp.last_match(0)
-              filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
-              @filters << parse_filter_expressions(filtername, filterargs)
-            end
-          end
+      @filters = []
+      return unless markup =~ VariableSyntax
+
+      add_syntax_warning("variable prefixed with ignored characters: #{$1.inspect}") if $1
+      name_markup = $2
+      add_syntax_warning("variable filter separator prefixed with ignored characters: #{$3.inspect}") if $3
+      filters_markup = $4
+      @name = Expression.parse(name_markup)
+      if filters_markup
+        filters_markup.scan(FilterParser) do |lax_sep, f|
+          add_syntax_warning("unterminated quote or multiple pipe characters used as a filter separator: #{lax_sep.inspect}") if lax_sep
+          next unless f =~ /\A\s*(\W+)??(\w+)/
+          add_syntax_warning("ignored characters before filter name: #{$1.inspect}") if $1
+          filtername = $2
+          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
+          @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
     end
 
     def strict_parse(markup)
-      @filters ||= []
-      @filters.clear
+      @filters = []
       p = Parser.new(markup)
 
       @name = Expression.parse(p.expression)
@@ -70,21 +80,26 @@ module Liquid
       # first argument
       filterargs = [p.argument]
       # followed by comma separated others
-      while p.consume?(:comma)
-        filterargs << p.argument
-      end
+      filterargs << p.argument while p.consume?(:comma)
       filterargs
     end
 
     def render(context)
       @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
         filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        output = context.invoke(filter_name, output, *filter_args)
-      end.tap{ |obj| taint_check(obj) }
+        context.invoke(filter_name, output, *filter_args)
+      end.tap{ |obj| taint_check(context, obj) }
     end
 
     private
 
+    def add_syntax_warning(warning)
+      return unless parse_context.error_mode == :lax_warn
+      error = SyntaxError.new(warning)
+      error.line_number = parse_context.line_number
+      parse_context.warnings << error
+    end
+
     def parse_filter_expressions(filter_name, unparsed_args)
       filter_args = []
       keyword_args = {}
@@ -112,17 +127,22 @@ module Liquid
       parsed_args
     end
 
-    def taint_check(obj)
-      if obj.tainted?
-        @markup =~ QuotedFragment
-        name = Regexp.last_match(0)
-        case Template.taint_mode
-        when :warn
-          @warnings ||= []
-          @warnings << "variable '#{name}' is tainted and was not escaped"
-        when :error
-          raise TaintedError, "Error - variable '#{name}' is tainted and was not escaped"
-        end
+    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

@@ -10,20 +10,21 @@ module Liquid
     end
 
     def initialize(markup)
-      @lookups = markup.scan(VariableParser)
+      lookups = markup.scan(VariableParser)
 
-      name = @lookups.shift
+      name = lookups.shift
       if name =~ SQUARE_BRACKETED
         name = Expression.parse($1)
       end
       @name = name
 
+      @lookups = lookups
       @command_flags = 0
 
       @lookups.each_index do |i|
-        lookup = @lookups[i]
+        lookup = lookups[i]
         if lookup =~ SQUARE_BRACKETED
-          @lookups[i] = Expression.parse($1)
+          lookups[i] = Expression.parse($1)
         elsif COMMAND_METHODS.include?(lookup)
           @command_flags |= 1 << i
         end
@@ -40,8 +41,8 @@ module Liquid
         # If object is a hash- or array-like object we look for the
         # presence of the key and if its available we return it
         if object.respond_to?(:[]) &&
-          ((object.respond_to?(:has_key?) && object.has_key?(key)) ||
-           (object.respond_to?(:fetch) && key.is_a?(Integer)))
+            ((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)
@@ -67,7 +68,7 @@ module Liquid
     end
 
     def ==(other)
-      self.class == other.class && self.state == other.state
+      self.class == other.class && state == other.state
     end
 
     protected

liquid.gemspec

@@ -1,6 +1,6 @@
 # encoding: utf-8
 lib = File.expand_path('../lib/', __FILE__)
-$:.unshift lib unless $:.include?(lib)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
 
 require "liquid/version"
 
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.email       = ["tobi@leetsoft.com"]
   s.homepage    = "http://www.liquidmarkup.org"
   s.license     = "MIT"
-  #s.description = "A secure, non-evaling end user template engine with aesthetic markup."
+  # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
   s.required_rubygems_version = ">= 1.3.7"
 

performance/benchmark.rb

@@ -1,5 +1,5 @@
 require 'benchmark/ips'
-require File.dirname(__FILE__) + '/theme_runner'
+require_relative 'theme_runner'
 
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new

performance/memory.rb

@@ -1,19 +0,0 @@
-at_exit do
-  p 'Objects distribution:'
-  require 'pp'
-  pp ObjectSpace.count_objects
-end
-
-require 'allocation_tracer' rescue fail("install allocation_tracer extension/gem")
-require File.dirname(__FILE__) + '/theme_runner'
-
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
-profiler = ThemeRunner.new
-
-require 'allocation_tracer/trace'
-
-puts "Profiling memory usage..."
-
-200.times do
-  profiler.run
-end

performance/profile.rb

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

performance/shopify/comment_form.rb

@@ -28,6 +28,6 @@ class CommentForm < Liquid::Block
   end
 
   def wrap_in_form(article, input)
-    %Q{<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>}
+    %(<form id="article-#{article.id}-comment-form" class="comment-form" method="post" action="">\n#{input}\n</form>)
   end
 end

performance/shopify/database.rb

@@ -5,7 +5,7 @@ module Database
   # to liquid as assigns. All this is based on Shopify
   def self.tables
     @tables ||= begin
-      db = YAML.load_file(File.dirname(__FILE__) + '/vision.database.yml')
+      db = YAML.load_file("#{__dir__}/vision.database.yml")
 
       # From vision source
       db['products'].each do |product|
@@ -39,7 +39,7 @@ module Database
   end
 end
 
-if __FILE__ == $0
+if __FILE__ == $PROGRAM_NAME
   p Database.tables['collections']['frontpage'].keys
-  #p Database.tables['blog']['articles']
+  # p Database.tables['blog']['articles']
 end

performance/shopify/json_filter.rb

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

performance/shopify/liquid.rb

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

performance/shopify/money_filter.rb

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

performance/shopify/paginate.rb

@@ -42,23 +42,22 @@ class Paginate < Liquid::Block
       page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1
 
       pagination['items']      = collection_size
-      pagination['pages']      = page_count -1
-      pagination['previous']   = link('&laquo; Previous', current_page-1 )  unless 1 >= current_page
-      pagination['next']       = link('Next &raquo;', current_page+1 )      unless page_count <= current_page+1
+      pagination['pages']      = page_count - 1
+      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless 1 >= current_page
+      pagination['next']       = link('Next &raquo;', current_page + 1)      unless page_count <= current_page + 1
       pagination['parts']      = []
 
       hellip_break = false
 
       if page_count > 2
-        1.upto(page_count-1) do |page|
-
+        1.upto(page_count - 1) do |page|
           if current_page == page
             pagination['parts'] << no_link(page)
           elsif page == 1
             pagination['parts'] << link(page, page)
-          elsif page == page_count -1
+          elsif page == page_count - 1
             pagination['parts'] << link(page, page)
-          elsif page <= current_page - @attributes['window_size'] or page >= current_page + @attributes['window_size']
+          elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
             next if hellip_break
             pagination['parts'] << no_link('&hellip;')
             hellip_break = true
@@ -78,11 +77,11 @@ class Paginate < Liquid::Block
   private
 
   def no_link(title)
-    { 'title' => title, 'is_link' => false}
+    { 'title' => title, 'is_link' => false }
   end
 
   def link(title, page)
-    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true}
+    { 'title' => title, 'url' => current_url + "?page=#{page}", 'is_link' => true }
   end
 
   def current_url

performance/shopify/shop_filter.rb

@@ -1,5 +1,4 @@
 module ShopFilter
-
   def asset_url(input)
     "/files/1/[shop_id]/[shop_id]/assets/#{input}"
   end
@@ -16,16 +15,16 @@ module ShopFilter
     %(<script src="#{url}" type="text/javascript"></script>)
   end
 
-  def stylesheet_tag(url, media="all")
+  def stylesheet_tag(url, media = "all")
     %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
   end
 
-  def link_to(link, url, title="")
-    %|<a href="#{url}" title="#{title}">#{link}</a>|
+  def link_to(link, url, title = "")
+    %(<a href="#{url}" title="#{title}">#{link}</a>)
   end
 
-  def img_tag(url, alt="")
-    %|<img src="#{url}" alt="#{alt}" />|
+  def img_tag(url, alt = "")
+    %(<img src="#{url}" alt="#{alt}" />)
   end
 
   def link_to_vendor(vendor)
@@ -53,7 +52,6 @@ module ShopFilter
   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
@@ -69,7 +67,6 @@ module ShopFilter
   end
 
   def default_pagination(paginate)
-
     html = []
     html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
 
@@ -106,5 +103,4 @@ module ShopFilter
     result.gsub!(/\A-+/, '') if result[0] == '-'
     result
   end
-
 end

performance/shopify/tag_filter.rb

@@ -1,10 +1,9 @@
 module TagFilter
-
   def link_to_tag(label, tag)
     "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"
   end
 
-  def highlight_active_tag(tag, css_class='active')
+  def highlight_active_tag(tag, css_class = 'active')
     if @context['current_tags'].include?(tag)
       "<span class=\"#{css_class}\">#{tag}</span>"
     else
@@ -21,5 +20,4 @@ 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,5 +1,4 @@
 module WeightFilter
-
   def weight(grams)
     sprintf("%.2f", grams / 1000)
   end
@@ -7,5 +6,4 @@ module WeightFilter
   def weight_with_unit(grams)
     "#{weight(grams)} kg"
   end
-
 end

performance/theme_runner.rb

@@ -6,12 +6,11 @@
 # Shopify which is likely the biggest user of liquid in the world which something to the tune of several
 # million Template#render calls a day.
 
-require File.dirname(__FILE__) + '/shopify/liquid'
-require File.dirname(__FILE__) + '/shopify/database.rb'
+require_relative 'shopify/liquid'
+require_relative 'shopify/database'
 
 class ThemeRunner
   class FileSystem
-
     def initialize(path)
       @path = path
     end
@@ -25,7 +24,7 @@ class ThemeRunner
   # Load all templates into memory, do this now so that
   # we don't profile IO.
   def initialize
-    @tests = Dir[File.dirname(__FILE__) + '/tests/**/*.liquid'].collect do |test|
+    @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
       next if File.basename(test) == 'theme.liquid'
 
       theme_path = File.dirname(test) + '/theme.liquid'
@@ -38,7 +37,6 @@ class ThemeRunner
     # Dup assigns because will make some changes to them
 
     @tests.each do |liquid, layout, template_name|
-
       tmpl = Liquid::Template.new
       tmpl.parse(liquid)
       tmpl = Liquid::Template.new
@@ -46,20 +44,17 @@ class ThemeRunner
     end
   end
 
-   def run
+  def run
     # 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
       page_template = File.basename(template_name, File.extname(template_name))
       compile_and_render(liquid, layout, assigns, page_template, template_name)
-
     end
   end
 
-
   def compile_and_render(template, layout, assigns, page_template, template_file)
     tmpl = Liquid::Template.new
     tmpl.assigns['page_title'] = 'Page title'

test/integration/assign_test.rb

@@ -15,24 +15,24 @@ class AssignTest < Minitest::Test
 
   def test_assigned_variable
     assert_template_result('.foo.',
-                           '{% assign foo = values %}.{{ foo[0] }}.',
-                           'values' => %w{foo bar baz})
+      '{% assign foo = values %}.{{ foo[0] }}.',
+      'values' => %w(foo bar baz))
 
     assert_template_result('.bar.',
-                           '{% assign foo = values %}.{{ foo[1] }}.',
-                           'values' => %w{foo bar baz})
+      '{% assign foo = values %}.{{ foo[1] }}.',
+      'values' => %w(foo bar baz))
   end
 
   def test_assign_with_filter
     assert_template_result('.bar.',
-                           '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
-                           'values' => "foo,bar,baz")
+      '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
+      'values' => "foo,bar,baz")
   end
 
   def test_assign_syntax_error
     assert_match_syntax_error(/assign/,
-                       '{% assign foo not values %}.',
-                       'values' => "foo,bar,baz")
+      '{% assign foo not values %}.',
+      'values' => "foo,bar,baz")
   end
 
   def test_assign_uses_error_mode

test/integration/blank_test.rb

@@ -31,7 +31,7 @@ class BlankTest < Minitest::Test
   end
 
   def test_new_tags_are_not_blank_by_default
-    assert_template_result(" "*N, wrap_in_for("{% foobar %}"))
+    assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
   end
 
   def test_loops_are_blank
@@ -47,7 +47,7 @@ class BlankTest < Minitest::Test
   end
 
   def test_mark_as_blank_only_during_parsing
-    assert_template_result(" "*(N+1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
+    assert_template_result(" " * (N + 1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
   end
 
   def test_comments_are_blank
@@ -60,9 +60,9 @@ class BlankTest < Minitest::Test
 
   def test_nested_blocks_are_blank_but_only_if_all_children_are
     assert_template_result("", wrap(wrap(" ")))
-    assert_template_result("\n       but this is not "*(N+1),
-      wrap(%q{{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
-      {% if true %} but this is not {% endif %}}))
+    assert_template_result("\n       but this is not " * (N + 1),
+      wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
+      {% if true %} but this is not {% endif %}'))
   end
 
   def test_assigns_are_blank
@@ -76,31 +76,31 @@ class BlankTest < Minitest::Test
 
   def test_whitespace_is_not_blank_if_other_stuff_is_present
     body = "     x "
-    assert_template_result(body*(N+1), wrap(body))
+    assert_template_result(body * (N + 1), wrap(body))
   end
 
   def test_increment_is_not_blank
-    assert_template_result(" 0"*2*(N+1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
+    assert_template_result(" 0" * 2 * (N + 1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
   end
 
   def test_cycle_is_not_blank
-    assert_template_result("  "*((N+1)/2)+" ", wrap("{% cycle ' ', ' ' %}"))
+    assert_template_result("  " * ((N + 1) / 2) + " ", wrap("{% cycle ' ', ' ' %}"))
   end
 
   def test_raw_is_not_blank
-    assert_template_result("  "*(N+1), wrap(" {% raw %} {% endraw %}"))
+    assert_template_result("  " * (N + 1), wrap(" {% raw %} {% endraw %}"))
   end
 
   def test_include_is_blank
     Liquid::Template.file_system = BlankTestFileSystem.new
-    assert_template_result "foobar"*(N+1), wrap("{% include 'foobar' %}")
-    assert_template_result " foobar "*(N+1), wrap("{% include ' foobar ' %}")
-    assert_template_result "   "*(N+1), wrap(" {% include ' ' %} ")
+    assert_template_result "foobar" * (N + 1), wrap("{% include 'foobar' %}")
+    assert_template_result " foobar " * (N + 1), wrap("{% include ' foobar ' %}")
+    assert_template_result "   " * (N + 1), wrap(" {% include ' ' %} ")
   end
 
   def test_case_is_blank
     assert_template_result("", wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
     assert_template_result("", wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
-    assert_template_result("   x  "*(N+1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
+    assert_template_result("   x  " * (N + 1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
   end
 end

test/integration/context_test.rb

@@ -18,14 +18,14 @@ class ContextTest < Minitest::Test
 
     with_global_filter(global) do
       assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, :filters => [local])
+      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, filters: [local])
     end
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
     with_error_mode :strict do
       context = Context.new
-      context.has_key?('unknown')
+      context.key?('unknown')
       assert_empty context.errors
     end
   end

test/integration/drop_test.rb

@@ -14,12 +14,11 @@ class ContextDrop < Liquid::Drop
   end
 
   def before_method(method)
-    return @context[method]
+    @context[method]
   end
 end
 
 class ProductDrop < Liquid::Drop
-
   class TextDrop < Liquid::Drop
     def array
       ['text1', 'text2']
@@ -32,7 +31,7 @@ class ProductDrop < Liquid::Drop
 
   class CatchallDrop < Liquid::Drop
     def before_method(method)
-      return 'method: ' << method.to_s
+      'method: ' << method.to_s
     end
   end
 
@@ -53,9 +52,10 @@ class ProductDrop < Liquid::Drop
   end
 
   protected
-    def callmenot
-      "protected"
-    end
+
+  def callmenot
+    "protected"
+  end
 end
 
 class EnumerableDrop < Liquid::Drop
@@ -124,8 +124,10 @@ class DropsTest < Minitest::Test
   def test_rendering_warns_on_tainted_attr
     with_taint_mode(:warn) do
       tpl = Liquid::Template.parse('{{ product.user_input }}')
-      tpl.render!('product' => ProductDrop.new)
-      assert_match /tainted/, tpl.warnings.first
+      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
 
@@ -151,37 +153,37 @@ class DropsTest < Minitest::Test
   end
 
   def test_text_drop
-    output = Liquid::Template.parse( ' {{ product.texts.text }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse(' {{ product.texts.text }} ').render!('product' => ProductDrop.new)
     assert_equal ' text1 ', output
   end
 
   def test_unknown_method
-    output = Liquid::Template.parse( ' {{ product.catchall.unknown }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse(' {{ product.catchall.unknown }} ').render!('product' => ProductDrop.new)
     assert_equal ' method: unknown ', output
   end
 
   def test_integer_argument_drop
-    output = Liquid::Template.parse( ' {{ product.catchall[8] }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse(' {{ product.catchall[8] }} ').render!('product' => ProductDrop.new)
     assert_equal ' method: 8 ', output
   end
 
   def test_text_array_drop
-    output = Liquid::Template.parse( '{% for text in product.texts.array %} {{text}} {% endfor %}'  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse('{% for text in product.texts.array %} {{text}} {% endfor %}').render!('product' => ProductDrop.new)
     assert_equal ' text1  text2 ', output
   end
 
   def test_context_drop
-    output = Liquid::Template.parse( ' {{ context.bar }} '  ).render!('context' => ContextDrop.new, 'bar' => "carrot")
+    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
     assert_equal ' carrot ', output
   end
 
   def test_nested_context_drop
-    output = Liquid::Template.parse( ' {{ product.context.foo }} '  ).render!('product' => ProductDrop.new, 'foo' => "monkey")
+    output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
     assert_equal ' monkey ', output
   end
 
   def test_protected
-    output = Liquid::Template.parse( ' {{ product.callmenot }} '  ).render!('product' => ProductDrop.new)
+    output = Liquid::Template.parse(' {{ product.callmenot }} ').render!('product' => ProductDrop.new)
     assert_equal '  ', output
   end
 
@@ -193,40 +195,40 @@ class DropsTest < Minitest::Test
   end
 
   def test_scope
-    assert_equal '1', Liquid::Template.parse( '{{ context.scopes }}'  ).render!('context' => ContextDrop.new)
-    assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ context.scopes }}{%endfor%}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '1', Liquid::Template.parse('{{ context.scopes }}').render!('context' => ContextDrop.new)
+    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ context.scopes }}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ context.scopes }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
   end
 
   def test_scope_though_proc
-    assert_equal '1', Liquid::Template.parse( '{{ s }}'  ).render!('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] })
-    assert_equal '2', Liquid::Template.parse( '{%for i in dummy%}{{ s }}{%endfor%}'  ).render!('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse( '{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}'  ).render!('context' => ContextDrop.new, 's' => Proc.new{|c| c['context.scopes'] }, 'dummy' => [1])
+    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)
+    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{{a}}').render!('context' => ContextDrop.new)
+    assert_equal 'variable', Liquid::Template.parse('{% assign a = "variable"%}{%for i in dummy%}{{a}}{%endfor%}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal 'test', Liquid::Template.parse('{% assign header_gif = "test"%}{{header_gif}}').render!('context' => ContextDrop.new)
+    assert_equal 'test', Liquid::Template.parse("{% assign header_gif = 'test'%}{{header_gif}}").render!('context' => ContextDrop.new)
   end
 
   def test_scope_from_tags
-    assert_equal '1', Liquid::Template.parse( '{% for i in context.scopes_as_array %}{{i}}{% endfor %}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '12', Liquid::Template.parse( '{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
-    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}'  ).render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '1', Liquid::Template.parse('{% for i in context.scopes_as_array %}{{i}}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '12', Liquid::Template.parse('{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
+    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{%for a in dummy%}{% for i in context.scopes_as_array %}{{i}}{% endfor %}{% endfor %}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1])
   end
 
   def test_access_context_from_drop
-    assert_equal '123', Liquid::Template.parse( '{%for a in dummy%}{{ context.loop_pos }}{% endfor %}'  ).render!('context' => ContextDrop.new, 'dummy' => [1,2,3])
+    assert_equal '123', Liquid::Template.parse('{%for a in dummy%}{{ context.loop_pos }}{% endfor %}').render!('context' => ContextDrop.new, 'dummy' => [1, 2, 3])
   end
 
   def test_enumerable_drop
-    assert_equal '123', Liquid::Template.parse( '{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
+    assert_equal '123', Liquid::Template.parse('{% for c in collection %}{{c}}{% endfor %}').render!('collection' => EnumerableDrop.new)
   end
 
   def test_enumerable_drop_size
-    assert_equal '3', Liquid::Template.parse( '{{collection.size}}').render!('collection' => EnumerableDrop.new)
+    assert_equal '3', Liquid::Template.parse('{{collection.size}}').render!('collection' => EnumerableDrop.new)
   end
 
   def test_enumerable_drop_will_invoke_before_method_for_clashing_method_names

test/integration/error_handling_test.rb

@@ -1,24 +1,5 @@
 require 'test_helper'
 
-class ErrorDrop < Liquid::Drop
-  def standard_error
-    raise Liquid::StandardError, 'standard error'
-  end
-
-  def argument_error
-    raise Liquid::ArgumentError, 'argument error'
-  end
-
-  def syntax_error
-    raise Liquid::SyntaxError, 'syntax error'
-  end
-
-  def exception
-    raise Exception, 'exception'
-  end
-
-end
-
 class ErrorHandlingTest < Minitest::Test
   include Liquid
 
@@ -56,7 +37,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_standard_error
-    template = Liquid::Template.parse( ' {{ errors.standard_error }} '  )
+    template = Liquid::Template.parse(' {{ errors.standard_error }} ')
     assert_equal ' Liquid error: standard error ', template.render('errors' => ErrorDrop.new)
 
     assert_equal 1, template.errors.size
@@ -64,7 +45,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_syntax
-    template = Liquid::Template.parse( ' {{ errors.syntax_error }} '  )
+    template = Liquid::Template.parse(' {{ errors.syntax_error }} ')
     assert_equal ' Liquid syntax error: syntax error ', template.render('errors' => ErrorDrop.new)
 
     assert_equal 1, template.errors.size
@@ -72,7 +53,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_argument
-    template = Liquid::Template.parse( ' {{ errors.argument_error }} '  )
+    template = Liquid::Template.parse(' {{ errors.argument_error }} ')
     assert_equal ' Liquid error: argument error ', template.render('errors' => ErrorDrop.new)
 
     assert_equal 1, template.errors.size
@@ -94,7 +75,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_lax_unrecognized_operator
-    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :lax)
+    template = Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :lax)
     assert_equal ' Liquid error: Unknown operator =! ', template.render
     assert_equal 1, template.errors.size
     assert_equal Liquid::ArgumentError, template.errors.first.class
@@ -102,14 +83,14 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_with_line_numbers_adds_numbers_to_parser_errors
     err = assert_raises(SyntaxError) do
-      template = Liquid::Template.parse(%q{
+      Liquid::Template.parse(%q(
           foobar
 
           {% "cat" | foobar %}
 
           bla
-        },
-        :line_numbers => true
+        ),
+        line_numbers: true
       )
     end
 
@@ -117,16 +98,16 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_parsing_warn_with_line_numbers_adds_numbers_to_lexer_errors
-    template = Liquid::Template.parse(%q{
+    template = Liquid::Template.parse('
         foobar
 
         {% if 1 =! 2 %}ok{% endif %}
 
         bla
-      },
-      :error_mode => :warn,
-      :line_numbers => true
-    )
+            ',
+      error_mode: :warn,
+      line_numbers: true
+                                     )
 
     assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
       template.warnings.map(&:message)
@@ -134,16 +115,16 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(%q{
+      Liquid::Template.parse('
           foobar
 
           {% if 1 =! 2 %}ok{% endif %}
 
           bla
-        },
-        :error_mode => :strict,
-        :line_numbers => true
-      )
+                ',
+        error_mode: :strict,
+        line_numbers: true
+                            )
     end
 
     assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
@@ -151,7 +132,7 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_syntax_errors_in_nested_blocks_have_correct_line_number
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(%q{
+      Liquid::Template.parse('
           foobar
 
           {% if 1 != 2 %}
@@ -159,9 +140,9 @@ class ErrorHandlingTest < Minitest::Test
           {% endif %}
 
           bla
-        },
-        :line_numbers => true
-      )
+                ',
+        line_numbers: true
+                            )
     end
 
     assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
@@ -169,18 +150,18 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_strict_error_messages
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', :error_mode => :strict)
+      Liquid::Template.parse(' {% if 1 =! 2 %}ok{% endif %} ', error_mode: :strict)
     end
     assert_equal 'Liquid syntax error: Unexpected character = in "1 =! 2"', err.message
 
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('{{%%%}}', :error_mode => :strict)
+      Liquid::Template.parse('{{%%%}}', error_mode: :strict)
     end
     assert_equal 'Liquid syntax error: Unexpected character % in "{{%%%}}"', err.message
   end
 
   def test_warnings
-    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', :error_mode => :warn)
+    template = Liquid::Template.parse('{% if ~~~ %}{{%%%}}{% else %}{{ hello. }}{% endif %}', error_mode: :warn)
     assert_equal 3, template.warnings.size
     assert_equal 'Unexpected character ~ in "~~~"', template.warnings[0].to_s(false)
     assert_equal 'Unexpected character % in "{{%%%}}"', template.warnings[1].to_s(false)
@@ -189,12 +170,12 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_warning_line_numbers
-    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", :error_mode => :warn, :line_numbers => true)
+    template = Liquid::Template.parse("{% if ~~~ %}\n{{%%%}}{% else %}\n{{ hello. }}{% endif %}", error_mode: :warn, line_numbers: true)
     assert_equal 'Liquid syntax error (line 1): Unexpected character ~ in "~~~"', template.warnings[0].message
     assert_equal 'Liquid syntax error (line 2): Unexpected character % in "{{%%%}}"', template.warnings[1].message
     assert_equal 'Liquid syntax error (line 3): Expected id but found end_of_string in "{{ hello. }}"', template.warnings[2].message
     assert_equal 3, template.warnings.size
-    assert_equal [1,2,3], template.warnings.map(&:line_number)
+    assert_equal [1, 2, 3], template.warnings.map(&:line_number)
   end
 
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
@@ -204,4 +185,42 @@ class ErrorHandlingTest < Minitest::Test
       template.render('errors' => ErrorDrop.new)
     end
   end
+
+  def test_exception_handler_with_string_result
+    template = Liquid::Template.parse('This is an argument error: {{ errors.argument_error }}')
+    output = template.render({ 'errors' => ErrorDrop.new }, exception_handler: ->(e) { '' })
+    assert_equal 'This is an argument error: ', output
+    assert_equal [ArgumentError], template.errors.map(&:class)
+  end
+
+  class InternalError < Liquid::Error
+  end
+
+  def test_exception_handler_with_exception_result
+    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
+    handler = ->(e) { e.is_a?(Liquid::Error) ? e : InternalError.new('internal') }
+    output = template.render({ 'errors' => ErrorDrop.new }, exception_handler: handler)
+    assert_equal 'This is a runtime error: Liquid error (line 1): internal', output
+    assert_equal [InternalError], template.errors.map(&:class)
+  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

@@ -17,7 +17,7 @@ module CanadianMoneyFilter
 end
 
 module SubstituteFilter
-  def substitute(input, params={})
+  def substitute(input, params = {})
     input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
   end
 end
@@ -39,13 +39,13 @@ class FiltersTest < Minitest::Test
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
 
-    assert_equal ' 1000$ ', Variable.new("var | money").render(@context)
+    assert_equal ' 1000$ ', Template.parse("{{var | money}}").render(@context)
   end
 
   def test_underscore_in_filter_name
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Variable.new("var | money_with_underscore").render(@context)
+    assert_equal ' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context)
   end
 
   def test_second_filter_overwrites_first
@@ -53,67 +53,100 @@ class FiltersTest < Minitest::Test
     @context.add_filters(MoneyFilter)
     @context.add_filters(CanadianMoneyFilter)
 
-    assert_equal ' 1000$ CAD ', Variable.new("var | money").render(@context)
+    assert_equal ' 1000$ CAD ', Template.parse("{{var | money}}").render(@context)
   end
 
   def test_size
     @context['var'] = 'abcd'
     @context.add_filters(MoneyFilter)
 
-    assert_equal 4, Variable.new("var | size").render(@context)
+    assert_equal '4', Template.parse("{{var | size}}").render(@context)
   end
 
   def test_join
-    @context['var'] = [1,2,3,4]
+    @context['var'] = [1, 2, 3, 4]
 
-    assert_equal "1 2 3 4", Variable.new("var | join").render(@context)
+    assert_equal "1 2 3 4", Template.parse("{{var | join}}").render(@context)
   end
 
   def test_sort
     @context['value'] = 3
-    @context['numbers'] = [2,1,4,3]
+    @context['numbers'] = [2, 1, 4, 3]
     @context['words'] = ['expected', 'as', 'alphabetic']
     @context['arrays'] = ['flower', 'are']
+    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
 
-    assert_equal [1,2,3,4], Variable.new("numbers | sort").render(@context)
-    assert_equal ['alphabetic', 'as', 'expected'], Variable.new("words | sort").render(@context)
-    assert_equal [3], Variable.new("value | sort").render(@context)
-    assert_equal ['are', 'flower'], Variable.new("arrays | sort").render(@context)
+    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", Variable.new("var | strip_html").render(@context)
+    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
   end
 
   def test_strip_html_ignore_comments_with_html
     @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
 
-    assert_equal "bla blub", Variable.new("var | strip_html").render(@context)
+    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
   end
 
   def test_capitalize
     @context['var'] = "blub"
 
-    assert_equal "Blub", Variable.new("var | capitalize").render(@context)
+    assert_equal "Blub", Template.parse("{{ var | capitalize }}").render(@context)
   end
 
   def test_nonexistent_filter_is_ignored
     @context['var'] = 1000
 
-    assert_equal 1000, Variable.new("var | xyzzy").render(@context)
+    assert_equal '1000', Template.parse("{{ var | xyzzy }}").render(@context)
   end
 
   def test_filter_with_keyword_arguments
     @context['surname'] = 'john'
+    @context['input'] = 'hello %{first_name}, %{last_name}'
     @context.add_filters(SubstituteFilter)
-    output = Variable.new(%! 'hello %{first_name}, %{last_name}' | substitute: first_name: surname, last_name: 'doe' !).render(@context)
+    output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
     assert_equal 'hello john, doe', output
   end
 
   def test_override_object_method_in_filter
-    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, :filters => [OverrideObjectMethodFilter])
+    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 })
@@ -126,8 +159,8 @@ class FiltersInTemplate < Minitest::Test
   def test_local_global
     with_global_filter(MoneyFilter) do
       assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => CanadianMoneyFilter)
-      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, :filters => [CanadianMoneyFilter])
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: CanadianMoneyFilter)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: [CanadianMoneyFilter])
     end
   end
 
@@ -136,3 +169,10 @@ class FiltersInTemplate < Minitest::Test
     assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
   end
 end # FiltersTest
+
+class TestObject < Liquid::Drop
+  attr_accessor :a
+  def initialize(a)
+    @a = a
+  end
+end

test/integration/output_test.rb

@@ -14,7 +14,7 @@ module FunnyFilter
   end
 
   def add_tag(input, tag = "p", id = "foo")
-    %|<#{tag} id="#{id}">#{input}</#{tag}>|
+    %(<#{tag} id="#{id}">#{input}</#{tag}>)
   end
 
   def paragraph(input)
@@ -22,9 +22,8 @@ module FunnyFilter
   end
 
   def link_to(name, url)
-    %|<a href="#{url}">#{name}</a>|
+    %(<a href="#{url}">#{name}</a>)
   end
-
 end
 
 class OutputTest < Minitest::Test
@@ -33,84 +32,84 @@ class OutputTest < Minitest::Test
   def setup
     @assigns = {
       'best_cars' => 'bmw',
-      'car' => {'bmw' => 'good', 'gm' => 'bad'}
-      }
+      'car' => { 'bmw' => 'good', 'gm' => 'bad' }
+    }
   end
 
   def test_variable
-    text = %| {{best_cars}} |
+    text = %( {{best_cars}} )
 
-    expected = %| bmw |
+    expected = %( bmw )
     assert_equal expected, Template.parse(text).render!(@assigns)
   end
 
   def test_variable_traversing
-    text = %| {{car.bmw}} {{car.gm}} {{car.bmw}} |
+    text = %( {{car.bmw}} {{car.gm}} {{car.bmw}} )
 
-    expected = %| good bad good |
+    expected = %( good bad good )
     assert_equal expected, Template.parse(text).render!(@assigns)
   end
 
   def test_variable_piping
     text = %( {{ car.gm | make_funny }} )
-    expected = %| LOL |
+    expected = %( LOL )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 
   def test_variable_piping_with_input
     text = %( {{ car.gm | cite_funny }} )
-    expected = %| LOL: bad |
+    expected = %( LOL: bad )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 
   def test_variable_piping_with_args
     text = %! {{ car.gm | add_smiley : ':-(' }} !
     expected = %| bad :-( |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 
   def test_variable_piping_with_no_args
-    text = %! {{ car.gm | add_smiley }} !
+    text = %( {{ car.gm | add_smiley }} )
     expected = %| bad :-) |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 
   def test_multiple_variable_piping_with_args
     text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
     expected = %| bad :-( :-( |
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 
   def test_variable_piping_with_multiple_args
-    text = %! {{ car.gm | add_tag : 'span', 'bar'}} !
-    expected = %| <span id="bar">bad</span> |
+    text = %( {{ car.gm | add_tag : 'span', 'bar'}} )
+    expected = %( <span id="bar">bad</span> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 
   def test_variable_piping_with_variable_args
-    text = %! {{ car.gm | add_tag : 'span', car.bmw}} !
-    expected = %| <span id="good">bad</span> |
+    text = %( {{ car.gm | add_tag : 'span', car.bmw}} )
+    expected = %( <span id="good">bad</span> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 
   def test_multiple_pipings
     text = %( {{ best_cars | cite_funny | paragraph }} )
-    expected = %| <p>LOL: bmw</p> |
+    expected = %( <p>LOL: bmw</p> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 
   def test_link_to
     text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
-    expected = %| <a href="http://typo.leetsoft.com">Typo</a> |
+    expected = %( <a href="http://typo.leetsoft.com">Typo</a> )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => [FunnyFilter])
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter])
   end
 end # OutputTest

test/integration/parsing_quirks_test.rb

@@ -62,25 +62,25 @@ class ParsingQuirksTest < Minitest::Test
   end
 
   def test_no_error_on_lax_empty_filter
-    assert Template.parse("{{test |a|b|}}", :error_mode => :lax)
-    assert Template.parse("{{test}}", :error_mode => :lax)
-    assert Template.parse("{{|test|}}", :error_mode => :lax)
+    assert Template.parse("{{test |a|b|}}", error_mode: :lax)
+    assert Template.parse("{{test}}", error_mode: :lax)
+    assert Template.parse("{{|test|}}", error_mode: :lax)
   end
 
   def test_meaningless_parens_lax
     with_error_mode(:lax) do
-      assigns = {'b' => 'bar', 'c' => 'baz'}
+      assigns = { 'b' => 'bar', 'c' => 'baz' }
       markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
-      assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}", assigns)
+      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
     end
   end
 
   def test_unexpected_characters_silently_eat_logic_lax
     with_error_mode(:lax) do
       markup = "true && false"
-      assert_template_result(' YES ',"{% if #{markup} %} YES {% endif %}")
+      assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
       markup = "false || true"
-      assert_template_result('',"{% if #{markup} %} YES {% endif %}")
+      assert_template_result('', "{% if #{markup} %} YES {% endif %}")
     end
   end
 
@@ -92,7 +92,7 @@ class ParsingQuirksTest < Minitest::Test
 
   def test_unanchored_filter_arguments
     with_error_mode(:lax) do
-      assert_template_result('hi',"{{ 'hi there' | split$$$:' ' | first }}")
+      assert_template_result('hi', "{{ 'hi there' | split$$$:' ' | first }}")
 
       assert_template_result('x', "{{ 'X' | downcase) }}")
 
@@ -115,5 +115,4 @@ class ParsingQuirksTest < Minitest::Test
       assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
     end
   end
-
 end # ParsingQuirksTest

test/integration/render_profiling_test.rb

@@ -21,7 +21,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_parse_makes_available_simple_profiling
-    t = Template.parse("{{ 'a string' | upcase }}", :profile => true)
+    t = Template.parse("{{ 'a string' | upcase }}", profile: true)
     t.render!
 
     assert_equal 1, t.profiler.length
@@ -31,14 +31,14 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_render_ignores_raw_strings_when_profiling
-    t = Template.parse("This is raw string\nstuff\nNewline", :profile => true)
+    t = Template.parse("This is raw string\nstuff\nNewline", profile: true)
     t.render!
 
     assert_equal 0, t.profiler.length
   end
 
   def test_profiling_includes_line_numbers_of_liquid_nodes
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
     t.render!
     assert_equal 2, t.profiler.length
 
@@ -49,7 +49,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_includes_line_numbers_of_included_partials
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
+    t = Template.parse("{% include 'a_template' %}", profile: true)
     t.render!
 
     included_children = t.profiler[0].children
@@ -61,7 +61,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_times_the_rendering_of_tokens
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
+    t = Template.parse("{% include 'a_template' %}", profile: true)
     t.render!
 
     node = t.profiler[0]
@@ -69,14 +69,14 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_times_the_entire_render
-    t = Template.parse("{% include 'a_template' %}", :profile => true)
+    t = Template.parse("{% include 'a_template' %}", profile: true)
     t.render!
 
     assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
   end
 
   def test_profiling_uses_include_to_mark_children
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
     t.render!
 
     include_node = t.profiler[1]
@@ -84,7 +84,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_marks_children_with_the_name_of_included_partial
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", :profile => true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
     t.render!
 
     include_node = t.profiler[1]
@@ -94,7 +94,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_supports_multiple_templates
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", :profile => true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'b_template' %}", profile: true)
     t.render!
 
     a_template = t.profiler[1]
@@ -109,7 +109,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_supports_rendering_the_same_partial_multiple_times
-    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", :profile => true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}\n{% include 'a_template' %}", profile: true)
     t.render!
 
     a_template1 = t.profiler[1]
@@ -124,7 +124,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_can_iterate_over_each_profiling_entry
-    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", :profile => true)
+    t = Template.parse("{{ 'a string' | upcase }}\n{% increment test %}", profile: true)
     t.render!
 
     timing_count = 0
@@ -136,7 +136,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_marks_children_of_if_blocks
-    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", :profile => true)
+    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
     t.render!
 
     assert_equal 1, t.profiler.length
@@ -144,8 +144,8 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_marks_children_of_for_blocks
-    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", :profile => true)
-    t.render!({"collection" => ["one", "two"]})
+    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
+    t.render!({ "collection" => ["one", "two"] })
 
     assert_equal 1, t.profiler.length
     # Will profile each invocation of the for block

test/integration/security_test.rb

@@ -11,32 +11,30 @@ class SecurityTest < Minitest::Test
 
   def test_no_instance_eval
     text = %( {{ '1+1' | instance_eval }} )
-    expected = %| 1+1 |
+    expected = %( 1+1 )
 
     assert_equal expected, Template.parse(text).render!(@assigns)
   end
 
   def test_no_existing_instance_eval
     text = %( {{ '1+1' | __instance_eval__ }} )
-    expected = %| 1+1 |
+    expected = %( 1+1 )
 
     assert_equal expected, Template.parse(text).render!(@assigns)
   end
 
-
   def test_no_instance_eval_after_mixing_in_new_filter
     text = %( {{ '1+1' | instance_eval }} )
-    expected = %| 1+1 |
+    expected = %( 1+1 )
 
     assert_equal expected, Template.parse(text).render!(@assigns)
   end
 
-
   def test_no_instance_eval_later_in_chain
     text = %( {{ '1+1' | add_one | instance_eval }} )
-    expected = %| 1+1 + 1 |
+    expected = %( 1+1 + 1 )
 
-    assert_equal expected, Template.parse(text).render!(@assigns, :filters => SecurityFilter)
+    assert_equal expected, Template.parse(text).render!(@assigns, filters: SecurityFilter)
   end
 
   def test_does_not_add_filters_to_symbol_table

test/integration/standard_filter_test.rb

@@ -49,7 +49,7 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_size
-    assert_equal 3, @filters.size([1,2,3])
+    assert_equal 3, @filters.size([1, 2, 3])
     assert_equal 0, @filters.size([])
     assert_equal 0, @filters.size(nil)
   end
@@ -76,20 +76,27 @@ class StandardFiltersTest < Minitest::Test
     assert_equal '', @filters.slice(nil, 0)
     assert_equal '', @filters.slice('foobar', 100, 10)
     assert_equal '', @filters.slice('foobar', -100, 10)
+    assert_equal 'oob', @filters.slice('foobar', '1', '3')
+    assert_raises(Liquid::ArgumentError) do
+      @filters.slice('foobar', nil)
+    end
+    assert_raises(Liquid::ArgumentError) do
+      @filters.slice('foobar', 0, "")
+    end
   end
 
   def test_slice_on_arrays
     input = 'foobar'.split(//)
-    assert_equal %w{o o b}, @filters.slice(input, 1, 3)
-    assert_equal %w{o o b a r}, @filters.slice(input, 1, 1000)
-    assert_equal %w{}, @filters.slice(input, 1, 0)
-    assert_equal %w{o}, @filters.slice(input, 1, 1)
-    assert_equal %w{b a r}, @filters.slice(input, 3, 3)
-    assert_equal %w{a r}, @filters.slice(input, -2, 2)
-    assert_equal %w{a r}, @filters.slice(input, -2, 1000)
-    assert_equal %w{r}, @filters.slice(input, -1)
-    assert_equal %w{}, @filters.slice(input, 100, 10)
-    assert_equal %w{}, @filters.slice(input, -100, 10)
+    assert_equal %w(o o b), @filters.slice(input, 1, 3)
+    assert_equal %w(o o b a r), @filters.slice(input, 1, 1000)
+    assert_equal %w(), @filters.slice(input, 1, 0)
+    assert_equal %w(o), @filters.slice(input, 1, 1)
+    assert_equal %w(b a r), @filters.slice(input, 3, 3)
+    assert_equal %w(a r), @filters.slice(input, -2, 2)
+    assert_equal %w(a r), @filters.slice(input, -2, 1000)
+    assert_equal %w(r), @filters.slice(input, -1)
+    assert_equal %w(), @filters.slice(input, 100, 10)
+    assert_equal %w(), @filters.slice(input, -100, 10)
   end
 
   def test_truncate
@@ -101,11 +108,11 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_split
-    assert_equal ['12','34'], @filters.split('12~34', '~')
-    assert_equal ['A? ',' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
+    assert_equal ['12', '34'], @filters.split('12~34', '~')
+    assert_equal ['A? ', ' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
     assert_equal ['A?Z'], @filters.split('A?Z', '~')
     # Regexp works although Liquid does not support.
-    assert_equal ['A','Z'], @filters.split('AxZ', /x/)
+    assert_equal ['A', 'Z'], @filters.split('AxZ', /x/)
     assert_equal [], @filters.split(nil, ' ')
   end
 
@@ -142,45 +149,46 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_join
-    assert_equal '1 2 3 4', @filters.join([1,2,3,4])
-    assert_equal '1 - 2 - 3 - 4', @filters.join([1,2,3,4], ' - ')
+    assert_equal '1 2 3 4', @filters.join([1, 2, 3, 4])
+    assert_equal '1 - 2 - 3 - 4', @filters.join([1, 2, 3, 4], ' - ')
   end
 
   def test_sort
-    assert_equal [1,2,3,4], @filters.sort([4,3,2,1])
-    assert_equal [{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], @filters.sort([{"a" => 4}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
+    assert_equal [1, 2, 3, 4], @filters.sort([4, 3, 2, 1])
+    assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], @filters.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
   end
 
   def test_legacy_sort_hash
-    assert_equal [{a:1, b:2}], @filters.sort({a:1, b:2})
+    assert_equal [{ a: 1, b: 2 }], @filters.sort({ a: 1, b: 2 })
   end
 
   def test_numerical_vs_lexicographical_sort
     assert_equal [2, 10], @filters.sort([10, 2])
-    assert_equal [{"a" => 2}, {"a" => 10}], @filters.sort([{"a" => 10}, {"a" => 2}], "a")
+    assert_equal [{ "a" => 2 }, { "a" => 10 }], @filters.sort([{ "a" => 10 }, { "a" => 2 }], "a")
     assert_equal ["10", "2"], @filters.sort(["10", "2"])
-    assert_equal [{"a" => "10"}, {"a" => "2"}], @filters.sort([{"a" => "10"}, {"a" => "2"}], "a")
+    assert_equal [{ "a" => "10" }, { "a" => "2" }], @filters.sort([{ "a" => "10" }, { "a" => "2" }], "a")
   end
 
   def test_uniq
-    assert_equal [1,3,2,4], @filters.uniq([1,1,3,2,3,1,4,3,2,1])
-    assert_equal [{"a" => 1}, {"a" => 3}, {"a" => 2}], @filters.uniq([{"a" => 1}, {"a" => 3}, {"a" => 1}, {"a" => 2}], "a")
+    assert_equal ["foo"], @filters.uniq("foo")
+    assert_equal [1, 3, 2, 4], @filters.uniq([1, 1, 3, 2, 3, 1, 4, 3, 2, 1])
+    assert_equal [{ "a" => 1 }, { "a" => 3 }, { "a" => 2 }], @filters.uniq([{ "a" => 1 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
     testdrop = TestDrop.new
     assert_equal [testdrop], @filters.uniq([testdrop, TestDrop.new], 'test')
   end
 
   def test_reverse
-    assert_equal [4,3,2,1], @filters.reverse([1,2,3,4])
+    assert_equal [4, 3, 2, 1], @filters.reverse([1, 2, 3, 4])
   end
 
   def test_legacy_reverse_hash
-    assert_equal [{a:1, b:2}], @filters.reverse(a:1, b:2)
+    assert_equal [{ a: 1, b: 2 }], @filters.reverse(a: 1, b: 2)
   end
 
   def test_map
-    assert_equal [1,2,3,4], @filters.map([{"a" => 1}, {"a" => 2}, {"a" => 3}, {"a" => 4}], 'a')
+    assert_equal [1, 2, 3, 4], @filters.map([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], 'a')
     assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
-      'ary' => [{'foo' => {'bar' => 'a'}}, {'foo' => {'bar' => 'b'}}, {'foo' => {'bar' => 'c'}}]
+      'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }]
   end
 
   def test_map_doesnt_call_arbitrary_stuff
@@ -212,7 +220,7 @@ class StandardFiltersTest < Minitest::Test
 
   def test_map_over_proc
     drop = TestDrop.new
-    p = Proc.new{ drop }
+    p = proc{ drop }
     templ = '{{ procs | map: "test" }}'
     assert_template_result "testfoo", templ, "procs" => [p]
   end
@@ -253,26 +261,32 @@ class StandardFiltersTest < Minitest::Test
 
     assert_equal nil, @filters.date(nil, "%B")
 
+    assert_equal '', @filters.date('', "%B")
+
     assert_equal "07/05/2006", @filters.date(1152098955, "%m/%d/%Y")
     assert_equal "07/05/2006", @filters.date("1152098955", "%m/%d/%Y")
   end
 
   def test_first_last
-    assert_equal 1, @filters.first([1,2,3])
-    assert_equal 3, @filters.last([1,2,3])
+    assert_equal 1, @filters.first([1, 2, 3])
+    assert_equal 3, @filters.last([1, 2, 3])
     assert_equal nil, @filters.first([])
     assert_equal nil, @filters.last([])
   end
 
   def test_replace
     assert_equal '2 2 2 2', @filters.replace('1 1 1 1', '1', 2)
+    assert_equal '2 2 2 2', @filters.replace('1 1 1 1', 1, 2)
     assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', '1', 2)
+    assert_equal '2 1 1 1', @filters.replace_first('1 1 1 1', 1, 2)
     assert_template_result '2 1 1 1', "{{ '1 1 1 1' | replace_first: '1', 2 }}"
   end
 
   def test_remove
     assert_equal '   ', @filters.remove("a a a a", 'a')
+    assert_equal '   ', @filters.remove("1 1 1 1", 1)
     assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')
+    assert_equal ' 1 1 1', @filters.remove_first("1 1 1 1", 1)
     assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}"
   end
 
@@ -331,32 +345,47 @@ class StandardFiltersTest < Minitest::Test
     assert_equal "Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render
 
     assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}"
+    assert_raises(Liquid::ZeroDivisionError) do
+      assert_template_result "4", "{{ 1 | modulo: 0 }}"
+    end
   end
 
   def test_modulo
     assert_template_result "1", "{{ 3 | modulo:2 }}"
+    assert_raises(Liquid::ZeroDivisionError) do
+      assert_template_result "4", "{{ 1 | modulo: 0 }}"
+    end
   end
 
   def test_round
     assert_template_result "5", "{{ input | round }}", 'input' => 4.6
     assert_template_result "4", "{{ '4.3' | round }}"
     assert_template_result "4.56", "{{ input | round: 2 }}", 'input' => 4.5612
+    assert_raises(Liquid::FloatDomainError) do
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | round }}"
+    end
   end
 
   def test_ceil
     assert_template_result "5", "{{ input | ceil }}", 'input' => 4.6
     assert_template_result "5", "{{ '4.3' | ceil }}"
+    assert_raises(Liquid::FloatDomainError) do
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | ceil }}"
+    end
   end
 
   def test_floor
     assert_template_result "4", "{{ input | floor }}", 'input' => 4.6
     assert_template_result "4", "{{ '4.3' | floor }}"
+    assert_raises(Liquid::FloatDomainError) do
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | floor }}"
+    end
   end
 
   def test_append
-    assigns = {'a' => 'bc', 'b' => 'd' }
-    assert_template_result('bcd',"{{ a | append: 'd'}}",assigns)
-    assert_template_result('bcd',"{{ a | append: b}}",assigns)
+    assigns = { 'a' => 'bc', 'b' => 'd' }
+    assert_template_result('bcd', "{{ a | append: 'd'}}", assigns)
+    assert_template_result('bcd', "{{ a | append: b}}", assigns)
   end
 
   def test_concat
@@ -371,9 +400,9 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_prepend
-    assigns = {'a' => 'bc', 'b' => 'a' }
-    assert_template_result('abc',"{{ a | prepend: 'a'}}",assigns)
-    assert_template_result('abc',"{{ a | prepend: b}}",assigns)
+    assigns = { 'a' => 'bc', 'b' => 'a' }
+    assert_template_result('abc', "{{ a | prepend: 'a'}}", assigns)
+    assert_template_result('abc', "{{ a | prepend: b}}", assigns)
   end
 
   def test_default
@@ -386,6 +415,6 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_cannot_access_private_methods
-    assert_template_result('a',"{{ 'a' | to_number }}")
+    assert_template_result('a', "{{ 'a' | to_number }}")
   end
 end # StandardFiltersTest

test/integration/tags/break_tag_test.rb

@@ -6,11 +6,10 @@ class BreakTagTest < Minitest::Test
   # tests that no weird errors are raised if break is called outside of a
   # block
   def test_break_with_no_block
-    assigns = {'i' => 1}
+    assigns = { 'i' => 1 }
     markup = '{% break %}'
     expected = ''
 
     assert_template_result(expected, markup, assigns)
   end
-
 end

test/integration/tags/continue_tag_test.rb

@@ -12,5 +12,4 @@ class ContinueTagTest < Minitest::Test
 
     assert_template_result(expected, markup, assigns)
   end
-
 end

test/integration/tags/for_tag_test.rb

@@ -10,10 +10,10 @@ class ForTagTest < Minitest::Test
   include Liquid
 
   def test_for
-    assert_template_result(' yo  yo  yo  yo ','{%for item in array%} yo {%endfor%}','array' => [1,2,3,4])
-    assert_template_result('yoyo','{%for item in array%}yo{%endfor%}','array' => [1,2])
-    assert_template_result(' yo ','{%for item in array%} yo {%endfor%}','array' => [1])
-    assert_template_result('','{%for item in array%}{%endfor%}','array' => [1,2])
+    assert_template_result(' yo  yo  yo  yo ', '{%for item in array%} yo {%endfor%}', 'array' => [1, 2, 3, 4])
+    assert_template_result('yoyo', '{%for item in array%}yo{%endfor%}', 'array' => [1, 2])
+    assert_template_result(' yo ', '{%for item in array%} yo {%endfor%}', 'array' => [1])
+    assert_template_result('', '{%for item in array%}{%endfor%}', 'array' => [1, 2])
     expected = <<HERE
 
   yo
@@ -28,46 +28,52 @@ HERE
   yo
 {%endfor%}
 HERE
-    assert_template_result(expected,template,'array' => [1,2,3])
+    assert_template_result(expected, template, 'array' => [1, 2, 3])
   end
 
   def test_for_reversed
-    assigns = {'array' => [ 1, 2, 3] }
-    assert_template_result('321','{%for item in array reversed %}{{item}}{%endfor%}',assigns)
+    assigns = { 'array' => [ 1, 2, 3] }
+    assert_template_result('321', '{%for item in array reversed %}{{item}}{%endfor%}', assigns)
   end
 
   def test_for_with_range
-    assert_template_result(' 1  2  3 ','{%for item in (1..3) %} {{item}} {%endfor%}')
+    assert_template_result(' 1  2  3 ', '{%for item in (1..3) %} {{item}} {%endfor%}')
+
+    assert_raises(Liquid::ArgumentError) do
+      Template.parse('{% for i in (a..2) %}{% endfor %}').render!("a" => [1, 2])
+    end
+
+    assert_template_result(' 0  1  2  3 ', '{% for item in (a..3) %} {{item}} {% endfor %}', "a" => "invalid integer")
   end
 
   def test_for_with_variable_range
-    assert_template_result(' 1  2  3 ','{%for item in (1..foobar) %} {{item}} {%endfor%}', "foobar" => 3)
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar) %} {{item}} {%endfor%}', "foobar" => 3)
   end
 
   def test_for_with_hash_value_range
     foobar = { "value" => 3 }
-    assert_template_result(' 1  2  3 ','{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
   end
 
   def test_for_with_drop_value_range
     foobar = ThingWithValue.new
-    assert_template_result(' 1  2  3 ','{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
+    assert_template_result(' 1  2  3 ', '{%for item in (1..foobar.value) %} {{item}} {%endfor%}', "foobar" => foobar)
   end
 
   def test_for_with_variable
-    assert_template_result(' 1  2  3 ','{%for item in array%} {{item}} {%endfor%}','array' => [1,2,3])
-    assert_template_result('123','{%for item in array%}{{item}}{%endfor%}','array' => [1,2,3])
-    assert_template_result('123','{% for item in array %}{{item}}{% endfor %}','array' => [1,2,3])
-    assert_template_result('abcd','{%for item in array%}{{item}}{%endfor%}','array' => ['a','b','c','d'])
-    assert_template_result('a b c','{%for item in array%}{{item}}{%endfor%}','array' => ['a',' ','b',' ','c'])
-    assert_template_result('abc','{%for item in array%}{{item}}{%endfor%}','array' => ['a','','b','','c'])
+    assert_template_result(' 1  2  3 ', '{%for item in array%} {{item}} {%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('123', '{%for item in array%}{{item}}{%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('123', '{% for item in array %}{{item}}{% endfor %}', 'array' => [1, 2, 3])
+    assert_template_result('abcd', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', 'b', 'c', 'd'])
+    assert_template_result('a b c', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', ' ', 'b', ' ', 'c'])
+    assert_template_result('abc', '{%for item in array%}{{item}}{%endfor%}', 'array' => ['a', '', 'b', '', 'c'])
   end
 
   def test_for_helpers
-    assigns = {'array' => [1,2,3] }
+    assigns = { 'array' => [1, 2, 3] }
     assert_template_result(' 1/3  2/3  3/3 ',
-                           '{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',
-                           assigns)
+      '{%for item in array%} {{forloop.index}}/{{forloop.length}} {%endfor%}',
+      assigns)
     assert_template_result(' 1  2  3 ', '{%for item in array%} {{forloop.index}} {%endfor%}', assigns)
     assert_template_result(' 0  1  2 ', '{%for item in array%} {{forloop.index0}} {%endfor%}', assigns)
     assert_template_result(' 2  1  0 ', '{%for item in array%} {{forloop.rindex0}} {%endfor%}', assigns)
@@ -77,20 +83,20 @@ HERE
   end
 
   def test_for_and_if
-    assigns = {'array' => [1,2,3] }
+    assigns = { 'array' => [1, 2, 3] }
     assert_template_result('+--',
-                           '{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}',
-                           assigns)
+      '{%for item in array%}{% if forloop.first %}+{% else %}-{% endif %}{%endfor%}',
+      assigns)
   end
 
   def test_for_else
-    assert_template_result('+++', '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>[1,2,3])
-    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>[])
-    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array'=>nil)
+    assert_template_result('+++', '{%for item in array%}+{%else%}-{%endfor%}', 'array' => [1, 2, 3])
+    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array' => [])
+    assert_template_result('-',   '{%for item in array%}+{%else%}-{%endfor%}', 'array' => nil)
   end
 
   def test_limiting
-    assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
+    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
     assert_template_result('12', '{%for i in array limit:2 %}{{ i }}{%endfor%}', assigns)
     assert_template_result('1234', '{%for i in array limit:4 %}{{ i }}{%endfor%}', assigns)
     assert_template_result('3456', '{%for i in array limit:4 offset:2 %}{{ i }}{%endfor%}', assigns)
@@ -98,7 +104,7 @@ HERE
   end
 
   def test_dynamic_variable_limiting
-    assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
+    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
     assigns['limit'] = 2
     assigns['offset'] = 2
 
@@ -106,17 +112,17 @@ HERE
   end
 
   def test_nested_for
-    assigns = {'array' => [[1,2],[3,4],[5,6]] }
+    assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
     assert_template_result('123456', '{%for item in array%}{%for i in item%}{{ i }}{%endfor%}{%endfor%}', assigns)
   end
 
   def test_offset_only
-    assigns = {'array' => [1,2,3,4,5,6,7,8,9,0]}
+    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
     assert_template_result('890', '{%for i in array offset:7 %}{{ i }}{%endfor%}', assigns)
   end
 
   def test_pause_resume
-    assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
     markup = <<-MKUP
       {%for i in array.items limit: 3 %}{{i}}{%endfor%}
       next
@@ -131,11 +137,11 @@ HERE
       next
       789
       XPCTD
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
   end
 
   def test_pause_resume_limit
-    assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
     markup = <<-MKUP
       {%for i in array.items limit:3 %}{{i}}{%endfor%}
       next
@@ -150,11 +156,11 @@ HERE
       next
       7
       XPCTD
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
   end
 
   def test_pause_resume_BIG_limit
-    assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
     markup = <<-MKUP
       {%for i in array.items limit:3 %}{{i}}{%endfor%}
       next
@@ -169,103 +175,102 @@ HERE
       next
       7890
       XPCTD
-      assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
   end
 
-
   def test_pause_resume_BIG_offset
-    assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,0]}}
-    markup = %q({%for i in array.items limit:3 %}{{i}}{%endfor%}
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
+    markup = '{%for i in array.items limit:3 %}{{i}}{%endfor%}
       next
       {%for i in array.items offset:continue limit:3 %}{{i}}{%endfor%}
       next
-      {%for i in array.items offset:continue limit:3 offset:1000 %}{{i}}{%endfor%})
-    expected = %q(123
+      {%for i in array.items offset:continue limit:3 offset:1000 %}{{i}}{%endfor%}'
+    expected = '123
       next
       456
       next
-      )
-      assert_template_result(expected,markup,assigns)
+      '
+    assert_template_result(expected, markup, assigns)
   end
 
   def test_for_with_break
-    assigns = {'array' => {'items' => [1,2,3,4,5,6,7,8,9,10]}}
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] } }
 
     markup = '{% for i in array.items %}{% break %}{% endfor %}'
     expected = ""
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     markup = '{% for i in array.items %}{{ i }}{% break %}{% endfor %}'
     expected = "1"
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     markup = '{% for i in array.items %}{% break %}{{ i }}{% endfor %}'
     expected = ""
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     markup = '{% for i in array.items %}{{ i }}{% if i > 3 %}{% break %}{% endif %}{% endfor %}'
     expected = "1234"
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     # tests to ensure it only breaks out of the local for loop
     # and not all of them.
-    assigns = {'array' => [[1,2],[3,4],[5,6]] }
-    markup = '{% for item in array %}' +
-               '{% for i in item %}' +
-                 '{% if i == 1 %}' +
-                   '{% break %}' +
-                 '{% endif %}' +
-                 '{{ i }}' +
-               '{% endfor %}' +
+    assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
+    markup = '{% for item in array %}' \
+               '{% for i in item %}' \
+                 '{% if i == 1 %}' \
+                   '{% break %}' \
+                 '{% endif %}' \
+                 '{{ i }}' \
+               '{% endfor %}' \
              '{% endfor %}'
     expected = '3456'
     assert_template_result(expected, markup, assigns)
 
     # test break does nothing when unreached
-    assigns = {'array' => {'items' => [1,2,3,4,5]}}
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
     markup = '{% for i in array.items %}{% if i == 9999 %}{% break %}{% endif %}{{ i }}{% endfor %}'
     expected = '12345'
     assert_template_result(expected, markup, assigns)
   end
 
   def test_for_with_continue
-    assigns = {'array' => {'items' => [1,2,3,4,5]}}
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
 
     markup = '{% for i in array.items %}{% continue %}{% endfor %}'
     expected = ""
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     markup = '{% for i in array.items %}{{ i }}{% continue %}{% endfor %}'
     expected = "12345"
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     markup = '{% for i in array.items %}{% continue %}{{ i }}{% endfor %}'
     expected = ""
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     markup = '{% for i in array.items %}{% if i > 3 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
     expected = "123"
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     markup = '{% for i in array.items %}{% if i == 3 %}{% continue %}{% else %}{{ i }}{% endif %}{% endfor %}'
     expected = "1245"
-    assert_template_result(expected,markup,assigns)
+    assert_template_result(expected, markup, assigns)
 
     # tests to ensure it only continues the local for loop and not all of them.
-    assigns = {'array' => [[1,2],[3,4],[5,6]] }
-    markup = '{% for item in array %}' +
-               '{% for i in item %}' +
-                 '{% if i == 1 %}' +
-                   '{% continue %}' +
-                 '{% endif %}' +
-                 '{{ i }}' +
-               '{% endfor %}' +
+    assigns = { 'array' => [[1, 2], [3, 4], [5, 6]] }
+    markup = '{% for item in array %}' \
+               '{% for i in item %}' \
+                 '{% if i == 1 %}' \
+                   '{% continue %}' \
+                 '{% endif %}' \
+                 '{{ i }}' \
+               '{% endfor %}' \
              '{% endfor %}'
     expected = '23456'
     assert_template_result(expected, markup, assigns)
 
     # test continue does nothing when unreached
-    assigns = {'array' => {'items' => [1,2,3,4,5]}}
+    assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5] } }
     markup = '{% for i in array.items %}{% if i == 9999 %}{% continue %}{% endif %}{{ i }}{% endfor %}'
     expected = '12345'
     assert_template_result(expected, markup, assigns)
@@ -277,41 +282,45 @@ HERE
     # the functionality for backwards compatibility
 
     assert_template_result('test string',
-                '{%for val in string%}{{val}}{%endfor%}',
-                'string' => "test string")
+      '{%for val in string%}{{val}}{%endfor%}',
+      'string' => "test string")
 
     assert_template_result('test string',
-                '{%for val in string limit:1%}{{val}}{%endfor%}',
-                'string' => "test string")
+      '{%for val in string limit:1%}{{val}}{%endfor%}',
+      'string' => "test string")
 
     assert_template_result('val-string-1-1-0-1-0-true-true-test string',
-                '{%for val in string%}' +
-                '{{forloop.name}}-' +
-                '{{forloop.index}}-' +
-                '{{forloop.length}}-' +
-                '{{forloop.index0}}-' +
-                '{{forloop.rindex}}-' +
-                '{{forloop.rindex0}}-' +
-                '{{forloop.first}}-' +
-                '{{forloop.last}}-' +
-                '{{val}}{%endfor%}',
-                'string' => "test string")
+      '{%for val in string%}' \
+      '{{forloop.name}}-' \
+      '{{forloop.index}}-' \
+      '{{forloop.length}}-' \
+      '{{forloop.index0}}-' \
+      '{{forloop.rindex}}-' \
+      '{{forloop.rindex0}}-' \
+      '{{forloop.first}}-' \
+      '{{forloop.last}}-' \
+      '{{val}}{%endfor%}',
+      'string' => "test string")
   end
 
   def test_for_parentloop_references_parent_loop
     assert_template_result('1.1 1.2 1.3 2.1 2.2 2.3 ',
-                           '{% for inner in outer %}{% for k in inner %}' +
-                           '{{ forloop.parentloop.index }}.{{ forloop.index }} ' +
-                           '{% endfor %}{% endfor %}',
-                           'outer' => [[1, 1, 1], [1, 1, 1]])
+      '{% for inner in outer %}{% for k in inner %}' \
+      '{{ forloop.parentloop.index }}.{{ forloop.index }} ' \
+      '{% endfor %}{% endfor %}',
+      'outer' => [[1, 1, 1], [1, 1, 1]])
   end
 
   def test_for_parentloop_nil_when_not_present
     assert_template_result('.1 .2 ',
-                           '{% for inner in outer %}' +
-                           '{{ forloop.parentloop.index }}.{{ forloop.index }} ' +
-                           '{% endfor %}',
-                           'outer' => [[1, 1, 1], [1, 1, 1]])
+      '{% for inner in outer %}' \
+      '{{ forloop.parentloop.index }}.{{ forloop.index }} ' \
+      '{% endfor %}',
+      'outer' => [[1, 1, 1], [1, 1, 1]])
+  end
+
+  def test_inner_for_over_empty_input
+    assert_template_result 'oo', '{% for a in (1..2) %}o{% for b in empty %}{% endfor %}{% endfor %}'
   end
 
   def test_blank_string_not_iterable
@@ -327,7 +336,7 @@ HERE
   def test_spacing_with_variable_naming_in_for_loop
     expected = '12345'
     template = '{% for       item   in   items %}{{item}}{% endfor %}'
-    assigns  = {'items' => [1,2,3,4,5]}
+    assigns  = { 'items' => [1, 2, 3, 4, 5] }
     assert_template_result(expected, template, assigns)
   end
 
@@ -345,13 +354,13 @@ HERE
 
     def load_slice(from, to)
       @load_slice_called = true
-      @data[(from..to-1)]
+      @data[(from..to - 1)]
     end
   end
 
   def test_iterate_with_each_when_no_limit_applied
-    loader = LoaderDrop.new([1,2,3,4,5])
-    assigns = {'items' => loader}
+    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns = { 'items' => loader }
     expected = '12345'
     template = '{% for item in items %}{{item}}{% endfor %}'
     assert_template_result(expected, template, assigns)
@@ -360,8 +369,8 @@ HERE
   end
 
   def test_iterate_with_load_slice_when_limit_applied
-    loader = LoaderDrop.new([1,2,3,4,5])
-    assigns = {'items' => loader}
+    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns = { 'items' => loader }
     expected = '1'
     template = '{% for item in items limit:1 %}{{item}}{% endfor %}'
     assert_template_result(expected, template, assigns)
@@ -370,8 +379,8 @@ HERE
   end
 
   def test_iterate_with_load_slice_when_limit_and_offset_applied
-    loader = LoaderDrop.new([1,2,3,4,5])
-    assigns = {'items' => loader}
+    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    assigns = { 'items' => loader }
     expected = '34'
     template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
     assert_template_result(expected, template, assigns)
@@ -380,12 +389,22 @@ HERE
   end
 
   def test_iterate_with_load_slice_returns_same_results_as_without
-    loader = LoaderDrop.new([1,2,3,4,5])
-    loader_assigns = {'items' => loader}
-    array_assigns = {'items' => [1,2,3,4,5]}
+    loader = LoaderDrop.new([1, 2, 3, 4, 5])
+    loader_assigns = { 'items' => loader }
+    array_assigns = { 'items' => [1, 2, 3, 4, 5] }
     expected = '34'
     template = '{% for item in items offset:2 limit:2 %}{{item}}{% endfor %}'
     assert_template_result(expected, template, loader_assigns)
     assert_template_result(expected, template, array_assigns)
   end
+
+  def test_for_cleans_up_registers
+    context = Context.new(ErrorDrop.new)
+
+    assert_raises(StandardError) do
+      Liquid::Template.parse('{% for i in (1..2) %}{{ standard_error }}{% endfor %}').render!(context)
+    end
+
+    assert context.registers[:for_stack].empty?
+  end
 end

test/integration/tags/if_else_tag_test.rb

@@ -4,101 +4,100 @@ class IfElseTagTest < Minitest::Test
   include Liquid
 
   def test_if
-    assert_template_result('  ',' {% if false %} this text should not go into the output {% endif %} ')
+    assert_template_result('  ', ' {% if false %} this text should not go into the output {% endif %} ')
     assert_template_result('  this text should go into the output  ',
-                           ' {% if true %} this text should go into the output {% endif %} ')
-    assert_template_result('  you rock ?','{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
+      ' {% if true %} this text should go into the output {% endif %} ')
+    assert_template_result('  you rock ?', '{% if false %} you suck {% endif %} {% if true %} you rock {% endif %}?')
   end
 
   def test_literal_comparisons
-    assert_template_result(' NO ','{% assign v = false %}{% if v %} YES {% else %} NO {% endif %}')
-    assert_template_result(' YES ','{% assign v = nil %}{% if v == nil %} YES {% else %} NO {% endif %}')
+    assert_template_result(' NO ', '{% assign v = false %}{% if v %} YES {% else %} NO {% endif %}')
+    assert_template_result(' YES ', '{% assign v = nil %}{% if v == nil %} YES {% else %} NO {% endif %}')
   end
 
   def test_if_else
-    assert_template_result(' YES ','{% if false %} NO {% else %} YES {% endif %}')
-    assert_template_result(' YES ','{% if true %} YES {% else %} NO {% endif %}')
-    assert_template_result(' YES ','{% if "foo" %} YES {% else %} NO {% endif %}')
+    assert_template_result(' YES ', '{% if false %} NO {% else %} YES {% endif %}')
+    assert_template_result(' YES ', '{% if true %} YES {% else %} NO {% endif %}')
+    assert_template_result(' YES ', '{% if "foo" %} YES {% else %} NO {% endif %}')
   end
 
   def test_if_boolean
-    assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => true)
   end
 
   def test_if_or
-    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)
-    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)
-    assert_template_result(' YES ','{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => true, 'b' => false)
+    assert_template_result(' YES ', '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => true)
     assert_template_result('',     '{% if a or b %} YES {% endif %}', 'a' => false, 'b' => false)
 
-    assert_template_result(' YES ','{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)
+    assert_template_result(' YES ', '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => true)
     assert_template_result('',     '{% if a or b or c %} YES {% endif %}', 'a' => false, 'b' => false, 'c' => false)
   end
 
   def test_if_or_with_operators
-    assert_template_result(' YES ','{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)
-    assert_template_result(' YES ','{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
-    assert_template_result('','{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ', '{% if a == true or b == true %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result(' YES ', '{% if a == true or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
+    assert_template_result('', '{% if a == false or b == false %} YES {% endif %}', 'a' => true, 'b' => true)
   end
 
   def test_comparison_of_strings_containing_and_or_or
     awful_markup = "a == 'and' and b == 'or' and c == 'foo and bar' and d == 'bar or baz' and e == 'foo' and foo and bar"
-    assigns = {'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true}
-    assert_template_result(' YES ',"{% if #{awful_markup} %} YES {% endif %}", assigns)
+    assigns = { 'a' => 'and', 'b' => 'or', 'c' => 'foo and bar', 'd' => 'bar or baz', 'e' => 'foo', 'foo' => true, 'bar' => true }
+    assert_template_result(' YES ', "{% if #{awful_markup} %} YES {% endif %}", assigns)
   end
 
   def test_comparison_of_expressions_starting_with_and_or_or
-    assigns = {'order' => {'items_count' => 0}, 'android' => {'name' => 'Roy'}}
-    assert_template_result( "YES",
-                            "{% if android.name == 'Roy' %}YES{% endif %}",
-                            assigns)
-    assert_template_result( "YES",
-                            "{% if order.items_count == 0 %}YES{% endif %}",
-                            assigns)
+    assigns = { 'order' => { 'items_count' => 0 }, 'android' => { 'name' => 'Roy' } }
+    assert_template_result("YES",
+      "{% if android.name == 'Roy' %}YES{% endif %}",
+      assigns)
+    assert_template_result("YES",
+      "{% if order.items_count == 0 %}YES{% endif %}",
+      assigns)
   end
 
   def test_if_and
-    assert_template_result(' YES ','{% if true and true %} YES {% endif %}')
-    assert_template_result('','{% if false and true %} YES {% endif %}')
-    assert_template_result('','{% if false and true %} YES {% endif %}')
+    assert_template_result(' YES ', '{% if true and true %} YES {% endif %}')
+    assert_template_result('', '{% if false and true %} YES {% endif %}')
+    assert_template_result('', '{% if false and true %} YES {% endif %}')
   end
 
-
   def test_hash_miss_generates_false
-    assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => {})
   end
 
   def test_if_from_variable
-    assert_template_result('','{% if var %} NO {% endif %}', 'var' => false)
-    assert_template_result('','{% if var %} NO {% endif %}', 'var' => nil)
-    assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {'bar' => false})
-    assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => {})
-    assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => nil)
-    assert_template_result('','{% if foo.bar %} NO {% endif %}', 'foo' => true)
+    assert_template_result('', '{% if var %} NO {% endif %}', 'var' => false)
+    assert_template_result('', '{% if var %} NO {% endif %}', 'var' => nil)
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => { 'bar' => false })
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => {})
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => nil)
+    assert_template_result('', '{% if foo.bar %} NO {% endif %}', 'foo' => true)
 
-    assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => "text")
-    assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => true)
-    assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => 1)
-    assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => {})
-    assert_template_result(' YES ','{% if var %} YES {% endif %}', 'var' => [])
-    assert_template_result(' YES ','{% if "foo" %} YES {% endif %}')
-    assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => true})
-    assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => "text"})
-    assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => 1 })
-    assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => {} })
-    assert_template_result(' YES ','{% if foo.bar %} YES {% endif %}', 'foo' => {'bar' => [] })
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => "text")
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => true)
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => 1)
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => {})
+    assert_template_result(' YES ', '{% if var %} YES {% endif %}', 'var' => [])
+    assert_template_result(' YES ', '{% if "foo" %} YES {% endif %}')
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => "text" })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => 1 })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => {} })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% endif %}', 'foo' => { 'bar' => [] })
 
-    assert_template_result(' YES ','{% if var %} NO {% else %} YES {% endif %}', 'var' => false)
-    assert_template_result(' YES ','{% if var %} NO {% else %} YES {% endif %}', 'var' => nil)
-    assert_template_result(' YES ','{% if var %} YES {% else %} NO {% endif %}', 'var' => true)
-    assert_template_result(' YES ','{% if "foo" %} YES {% else %} NO {% endif %}', 'var' => "text")
+    assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', 'var' => false)
+    assert_template_result(' YES ', '{% if var %} NO {% else %} YES {% endif %}', 'var' => nil)
+    assert_template_result(' YES ', '{% if var %} YES {% else %} NO {% endif %}', 'var' => true)
+    assert_template_result(' YES ', '{% if "foo" %} YES {% else %} NO {% endif %}', 'var' => "text")
 
-    assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {'bar' => false})
-    assert_template_result(' YES ','{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => {'bar' => true})
-    assert_template_result(' YES ','{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => {'bar' => "text"})
-    assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {'notbar' => true})
-    assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {})
-    assert_template_result(' YES ','{% if foo.bar %} NO {% else %} YES {% endif %}', 'notfoo' => {'bar' => true})
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => { 'bar' => false })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => { 'bar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} YES {% else %} NO {% endif %}', 'foo' => { 'bar' => "text" })
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => { 'notbar' => true })
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'foo' => {})
+    assert_template_result(' YES ', '{% if foo.bar %} NO {% else %} YES {% endif %}', 'notfoo' => { 'bar' => true })
   end
 
   def test_nested_if
@@ -110,31 +109,30 @@ class IfElseTagTest < Minitest::Test
     assert_template_result(' YES ', '{% if true %}{% if true %} YES {% else %} NO {% endif %}{% else %} NO {% endif %}')
     assert_template_result(' YES ', '{% if true %}{% if false %} NO {% else %} YES {% endif %}{% else %} NO {% endif %}')
     assert_template_result(' YES ', '{% if false %}{% if true %} NO {% else %} NONO {% endif %}{% else %} YES {% endif %}')
-
   end
 
   def test_comparisons_on_null
-    assert_template_result('','{% if null < 10 %} NO {% endif %}')
-    assert_template_result('','{% if null <= 10 %} NO {% endif %}')
-    assert_template_result('','{% if null >= 10 %} NO {% endif %}')
-    assert_template_result('','{% if null > 10 %} NO {% endif %}')
+    assert_template_result('', '{% if null < 10 %} NO {% endif %}')
+    assert_template_result('', '{% if null <= 10 %} NO {% endif %}')
+    assert_template_result('', '{% if null >= 10 %} NO {% endif %}')
+    assert_template_result('', '{% if null > 10 %} NO {% endif %}')
 
-    assert_template_result('','{% if 10 < null %} NO {% endif %}')
-    assert_template_result('','{% if 10 <= null %} NO {% endif %}')
-    assert_template_result('','{% if 10 >= null %} NO {% endif %}')
-    assert_template_result('','{% if 10 > null %} NO {% endif %}')
+    assert_template_result('', '{% if 10 < null %} NO {% endif %}')
+    assert_template_result('', '{% if 10 <= null %} NO {% endif %}')
+    assert_template_result('', '{% if 10 >= null %} NO {% endif %}')
+    assert_template_result('', '{% if 10 > null %} NO {% endif %}')
   end
 
   def test_else_if
-    assert_template_result('0','{% if 0 == 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
-    assert_template_result('1','{% if 0 != 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
-    assert_template_result('2','{% if 0 != 0 %}0{% elsif 1 != 1%}1{% else %}2{% endif %}')
+    assert_template_result('0', '{% if 0 == 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
+    assert_template_result('1', '{% if 0 != 0 %}0{% elsif 1 == 1%}1{% else %}2{% endif %}')
+    assert_template_result('2', '{% if 0 != 0 %}0{% elsif 1 != 1%}1{% else %}2{% endif %}')
 
-    assert_template_result('elsif','{% if false %}if{% elsif true %}elsif{% endif %}')
+    assert_template_result('elsif', '{% if false %}if{% elsif true %}elsif{% endif %}')
   end
 
   def test_syntax_error_no_variable
-    assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}')}
+    assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}') }
   end
 
   def test_syntax_error_no_expression
@@ -156,7 +154,7 @@ class IfElseTagTest < Minitest::Test
     Condition.operators['contains'] = :[]
 
     assert_template_result('yes',
-                           %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
+      %({% if 'gnomeslab-and-or-liquid' contains 'gnomeslab-and-or-liquid' %}yes{% endif %}))
   ensure
     Condition.operators['contains'] = original_op
   end
@@ -166,4 +164,25 @@ class IfElseTagTest < Minitest::Test
       assert_template_result('', %({% if 1 or throw or or 1 %}yes{% endif %}))
     end
   end
+
+  def test_multiple_conditions
+    tpl = "{% if a or b and c %}true{% else %}false{% endif %}"
+
+    tests = {
+      [true, true, true] => true,
+      [true, true, false] => true,
+      [true, false, true] => true,
+      [true, false, false] => true,
+      [false, true, true] => true,
+      [false, true, false] => false,
+      [false, false, true] => false,
+      [false, false, false] => false,
+    }
+
+    tests.each do |vals, expected|
+      a, b, c = vals
+      assigns = { 'a' => a, 'b' => b, 'c' => c }
+      assert_template_result expected.to_s, tpl, assigns, assigns.to_s
+    end
+  end
 end

test/integration/tags/include_tag_test.rb

@@ -77,23 +77,22 @@ class IncludeTagTest < Minitest::Test
 
   def test_include_tag_looks_for_file_system_in_registers_first
     assert_equal 'from OtherFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => OtherFileSystem.new})
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: OtherFileSystem.new })
   end
 
-
   def test_include_tag_with
     assert_template_result "Product: Draft 151cm ",
-      "{% include 'product' with products[0] %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
+      "{% include 'product' with products[0] %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
   end
 
   def test_include_tag_with_default_name
     assert_template_result "Product: Draft 151cm ",
-      "{% include 'product' %}", "product" => {'title' => 'Draft 151cm'}
+      "{% include 'product' %}", "product" => { 'title' => 'Draft 151cm' }
   end
 
   def test_include_tag_for
     assert_template_result "Product: Draft 151cm Product: Element 155cm ",
-      "{% include 'product' for products %}", "products" => [ {'title' => 'Draft 151cm'}, {'title' => 'Element 155cm'} ]
+      "{% include 'product' for products %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
   end
 
   def test_include_tag_with_local_variables
@@ -108,7 +107,7 @@ class IncludeTagTest < Minitest::Test
   def test_include_tag_with_multiple_local_variables_from_context
     assert_template_result "Locale: test123 test321",
       "{% include 'locale_variables' echo1: echo1, echo2: more_echos.echo2 %}",
-      'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321'}
+      'echo1' => 'test123', 'more_echos' => { "echo2" => 'test321' }
   end
 
   def test_included_templates_assigns_variables
@@ -123,14 +122,13 @@ class IncludeTagTest < Minitest::Test
 
   def test_nested_include_with_variable
     assert_template_result "Product: Draft 151cm details ",
-      "{% include 'nested_product_template' with product %}", "product" => {"title" => 'Draft 151cm'}
+      "{% include 'nested_product_template' with product %}", "product" => { "title" => 'Draft 151cm' }
 
     assert_template_result "Product: Draft 151cm details Product: Element 155cm details ",
-      "{% include 'nested_product_template' for products %}", "products" => [{"title" => 'Draft 151cm'}, {"title" => 'Element 155cm'}]
+      "{% include 'nested_product_template' for products %}", "products" => [{ "title" => 'Draft 151cm' }, { "title" => 'Element 155cm' }]
   end
 
   def test_recursively_included_template_does_not_produce_endless_loop
-
     infinite_file_system = Class.new do
       def read_template_file(template_path)
         "-{% include 'loop' %}"
@@ -142,7 +140,6 @@ class IncludeTagTest < Minitest::Test
     assert_raises(Liquid::StackLevelError, SystemStackError) do
       Template.parse("{% include 'loop' %}").render!
     end
-
   end
 
   def test_dynamically_choosen_template
@@ -150,24 +147,24 @@ class IncludeTagTest < Minitest::Test
     assert_template_result "Test321", "{% include template %}", "template" => 'Test321'
 
     assert_template_result "Product: Draft 151cm ", "{% include template for product %}",
-      "template" => 'product', 'product' => { 'title' => 'Draft 151cm'}
+      "template" => 'product', 'product' => { 'title' => 'Draft 151cm' }
   end
 
   def test_include_tag_caches_second_read_of_same_partial
     file_system = CountingFileSystem.new
     assert_equal 'from CountingFileSystemfrom CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+      Template.parse("{% include 'pick_a_source' %}{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })
     assert_equal 1, file_system.count
   end
 
   def test_include_tag_doesnt_cache_partials_across_renders
     file_system = CountingFileSystem.new
     assert_equal 'from CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })
     assert_equal 1, file_system.count
 
     assert_equal 'from CountingFileSystem',
-      Template.parse("{% include 'pick_a_source' %}").render!({}, :registers => {:file_system => file_system})
+      Template.parse("{% include 'pick_a_source' %}").render!({}, registers: { file_system: file_system })
     assert_equal 2, file_system.count
   end
 
@@ -219,4 +216,12 @@ class IncludeTagTest < Minitest::Test
       assert_equal 'x', Template.parse("{% include template %}", error_mode: :strict, include_options_blacklist: [:error_mode]).render!("template" => '{{ "X" || downcase }}')
     end
   end
+
+  def test_including_via_variable_value
+    assert_template_result "from TestFileSystem", "{% assign page = 'pick_a_source' %}{% include page %}"
+
+    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page %}", "product" => { 'title' => 'Draft 151cm' }
+
+    assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' }
+  end
 end # IncludeTagTest

test/integration/tags/increment_tag_test.rb

@@ -4,21 +4,20 @@ class IncrementTagTest < Minitest::Test
   include Liquid
 
   def test_inc
-    assert_template_result('0','{%increment port %}', {})
-    assert_template_result('0 1','{%increment port %} {%increment port%}', {})
+    assert_template_result('0', '{%increment port %}', {})
+    assert_template_result('0 1', '{%increment port %} {%increment port%}', {})
     assert_template_result('0 0 1 2 1',
-                           '{%increment port %} {%increment starboard%} ' +
-                           '{%increment port %} {%increment port%} ' +
-                           '{%increment starboard %}', {})
+      '{%increment port %} {%increment starboard%} ' \
+      '{%increment port %} {%increment port%} ' \
+      '{%increment starboard %}', {})
   end
 
   def test_dec
-    assert_template_result('9','{%decrement port %}', { 'port' => 10})
-    assert_template_result('-1 -2','{%decrement port %} {%decrement port%}', {})
+    assert_template_result('9', '{%decrement port %}', { 'port' => 10 })
+    assert_template_result('-1 -2', '{%decrement port %} {%decrement port%}', {})
     assert_template_result('1 5 2 2 5',
-                           '{%increment port %} {%increment starboard%} ' +
-                           '{%increment port %} {%decrement port%} ' +
-                           '{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
+      '{%increment port %} {%increment starboard%} ' \
+      '{%increment port %} {%decrement port%} ' \
+      '{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
   end
-
 end

test/integration/tags/raw_tag_test.rb

@@ -5,7 +5,7 @@ class RawTagTest < Minitest::Test
 
   def test_tag_in_raw
     assert_template_result '{% comment %} test {% endcomment %}',
-                           '{% raw %}{% comment %} test {% endcomment %}{% endraw %}'
+      '{% raw %}{% comment %} test {% endcomment %}{% endraw %}'
   end
 
   def test_output_in_raw
@@ -22,4 +22,10 @@ class RawTagTest < Minitest::Test
     assert_template_result ' test {% raw %} {% endraw %}', '{% raw %} test {% raw %} {% {% endraw %}endraw %}'
     assert_template_result ' Foobar {{ invalid 1', '{% raw %} Foobar {{ invalid {% endraw %}{{ 1 }}'
   end
+
+  def test_invalid_raw
+    assert_match_syntax_error /tag was never closed/, '{% raw %} foo'
+    assert_match_syntax_error /Valid syntax/, '{% raw } foo {% endraw %}'
+    assert_match_syntax_error /Valid syntax/, '{% raw } foo %}{% endraw %}'
+  end
 end

test/integration/tags/standard_tag_test.rb

@@ -5,116 +5,116 @@ class StandardTagTest < Minitest::Test
 
   def test_no_transform
     assert_template_result('this text should come out of the template without change...',
-                           'this text should come out of the template without change...')
+      'this text should come out of the template without change...')
 
-    assert_template_result('blah','blah')
-    assert_template_result('<blah>','<blah>')
-    assert_template_result('|,.:','|,.:')
-    assert_template_result('','')
+    assert_template_result('blah', 'blah')
+    assert_template_result('<blah>', '<blah>')
+    assert_template_result('|,.:', '|,.:')
+    assert_template_result('', '')
 
-    text = %|this shouldnt see any transformation either but has multiple lines
-              as you can clearly see here ...|
-    assert_template_result(text,text)
+    text = %(this shouldnt see any transformation either but has multiple lines
+              as you can clearly see here ...)
+    assert_template_result(text, text)
   end
 
   def test_has_a_block_which_does_nothing
-    assert_template_result(%|the comment block should be removed  .. right?|,
-                           %|the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?|)
+    assert_template_result(%(the comment block should be removed  .. right?),
+      %(the comment block should be removed {%comment%} be gone.. {%endcomment%} .. right?))
 
-    assert_template_result('','{%comment%}{%endcomment%}')
-    assert_template_result('','{%comment%}{% endcomment %}')
-    assert_template_result('','{% comment %}{%endcomment%}')
-    assert_template_result('','{% comment %}{% endcomment %}')
-    assert_template_result('','{%comment%}comment{%endcomment%}')
-    assert_template_result('','{% comment %}comment{% endcomment %}')
-    assert_template_result('','{% comment %} 1 {% comment %} 2 {% endcomment %} 3 {% endcomment %}')
+    assert_template_result('', '{%comment%}{%endcomment%}')
+    assert_template_result('', '{%comment%}{% endcomment %}')
+    assert_template_result('', '{% comment %}{%endcomment%}')
+    assert_template_result('', '{% comment %}{% endcomment %}')
+    assert_template_result('', '{%comment%}comment{%endcomment%}')
+    assert_template_result('', '{% comment %}comment{% endcomment %}')
+    assert_template_result('', '{% comment %} 1 {% comment %} 2 {% endcomment %} 3 {% endcomment %}')
 
-    assert_template_result('','{%comment%}{%blabla%}{%endcomment%}')
-    assert_template_result('','{% comment %}{% blabla %}{% endcomment %}')
-    assert_template_result('','{%comment%}{% endif %}{%endcomment%}')
-    assert_template_result('','{% comment %}{% endwhatever %}{% endcomment %}')
-    assert_template_result('','{% comment %}{% raw %} {{%%%%}}  }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
+    assert_template_result('', '{%comment%}{%blabla%}{%endcomment%}')
+    assert_template_result('', '{% comment %}{% blabla %}{% endcomment %}')
+    assert_template_result('', '{%comment%}{% endif %}{%endcomment%}')
+    assert_template_result('', '{% comment %}{% endwhatever %}{% endcomment %}')
+    assert_template_result('', '{% comment %}{% raw %} {{%%%%}}  }} { {% endcomment %} {% comment {% endraw %} {% endcomment %}')
 
-    assert_template_result('foobar','foo{%comment%}comment{%endcomment%}bar')
-    assert_template_result('foobar','foo{% comment %}comment{% endcomment %}bar')
-    assert_template_result('foobar','foo{%comment%} comment {%endcomment%}bar')
-    assert_template_result('foobar','foo{% comment %} comment {% endcomment %}bar')
+    assert_template_result('foobar', 'foo{%comment%}comment{%endcomment%}bar')
+    assert_template_result('foobar', 'foo{% comment %}comment{% endcomment %}bar')
+    assert_template_result('foobar', 'foo{%comment%} comment {%endcomment%}bar')
+    assert_template_result('foobar', 'foo{% comment %} comment {% endcomment %}bar')
 
-    assert_template_result('foo  bar','foo {%comment%} {%endcomment%} bar')
-    assert_template_result('foo  bar','foo {%comment%}comment{%endcomment%} bar')
-    assert_template_result('foo  bar','foo {%comment%} comment {%endcomment%} bar')
+    assert_template_result('foo  bar', 'foo {%comment%} {%endcomment%} bar')
+    assert_template_result('foo  bar', 'foo {%comment%}comment{%endcomment%} bar')
+    assert_template_result('foo  bar', 'foo {%comment%} comment {%endcomment%} bar')
 
-    assert_template_result('foobar','foo{%comment%}
+    assert_template_result('foobar', 'foo{%comment%}
                                      {%endcomment%}bar')
   end
 
   def test_hyphenated_assign
-    assigns = {'a-b' => '1' }
+    assigns = { 'a-b' => '1' }
     assert_template_result('a-b:1 a-b:2', 'a-b:{{a-b}} {%assign a-b = 2 %}a-b:{{a-b}}', assigns)
   end
 
   def test_assign_with_colon_and_spaces
-    assigns = {'var' => {'a:b c' => {'paged' => '1' }}}
+    assigns = { 'var' => { 'a:b c' => { 'paged' => '1' } } }
     assert_template_result('var2: 1', '{%assign var2 = var["a:b c"].paged %}var2: {{var2}}', assigns)
   end
 
   def test_capture
-    assigns = {'var' => 'content' }
+    assigns = { 'var' => 'content' }
     assert_template_result('content foo content foo ',
-                           '{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
-                           assigns)
+      '{{ var2 }}{% capture var2 %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
+      assigns)
   end
 
   def test_capture_detects_bad_syntax
     assert_raises(SyntaxError) do
       assert_template_result('content foo content foo ',
-                             '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
-                             {'var' => 'content' })
+        '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
+        { 'var' => 'content' })
     end
   end
 
   def test_case
-    assigns = {'condition' => 2 }
+    assigns = { 'condition' => 2 }
     assert_template_result(' its 2 ',
-                           '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
-                           assigns)
+      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+      assigns)
 
-    assigns = {'condition' => 1 }
+    assigns = { 'condition' => 1 }
     assert_template_result(' its 1 ',
-                           '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
-                           assigns)
+      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+      assigns)
 
-    assigns = {'condition' => 3 }
+    assigns = { 'condition' => 3 }
     assert_template_result('',
-                           '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
-                           assigns)
+      '{% case condition %}{% when 1 %} its 1 {% when 2 %} its 2 {% endcase %}',
+      assigns)
 
-    assigns = {'condition' => "string here" }
+    assigns = { 'condition' => "string here" }
     assert_template_result(' hit ',
-                           '{% case condition %}{% when "string here" %} hit {% endcase %}',
-                           assigns)
+      '{% case condition %}{% when "string here" %} hit {% endcase %}',
+      assigns)
 
-    assigns = {'condition' => "bad string here" }
+    assigns = { 'condition' => "bad string here" }
     assert_template_result('',
-                           '{% case condition %}{% when "string here" %} hit {% endcase %}',\
-                           assigns)
+      '{% case condition %}{% when "string here" %} hit {% endcase %}',\
+      assigns)
   end
 
   def test_case_with_else
-    assigns = {'condition' => 5 }
+    assigns = { 'condition' => 5 }
     assert_template_result(' hit ',
-                           '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
-                           assigns)
+      '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
+      assigns)
 
-    assigns = {'condition' => 6 }
+    assigns = { 'condition' => 6 }
     assert_template_result(' else ',
-                           '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
-                           assigns)
+      '{% case condition %}{% when 5 %} hit {% else %} else {% endcase %}',
+      assigns)
 
-    assigns = {'condition' => 6 }
+    assigns = { 'condition' => 6 }
     assert_template_result(' else ',
-                           '{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}',
-                           assigns)
+      '{% case condition %} {% when 5 %} hit {% else %} else {% endcase %}',
+      assigns)
   end
 
   def test_case_on_size
@@ -128,87 +128,87 @@ class StandardTagTest < Minitest::Test
 
   def test_case_on_size_with_else
     assert_template_result('else',
-                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-                           'a' => [])
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [])
 
     assert_template_result('1',
-                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-                           'a' => [1])
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1])
 
     assert_template_result('2',
-                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-                           'a' => [1, 1])
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1, 1])
 
     assert_template_result('else',
-                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-                           'a' => [1, 1, 1])
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1, 1, 1])
 
     assert_template_result('else',
-                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-                           'a' => [1, 1, 1, 1])
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1, 1, 1, 1])
 
     assert_template_result('else',
-                           '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
-                           'a' => [1, 1, 1, 1, 1])
+      '{% case a.size %}{% when 1 %}1{% when 2 %}2{% else %}else{% endcase %}',
+      'a' => [1, 1, 1, 1, 1])
   end
 
   def test_case_on_length_with_else
     assert_template_result('else',
-                           '{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
-                           {})
+      '{% case a.empty? %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+      {})
 
     assert_template_result('false',
-                           '{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
-                           {})
+      '{% case false %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+      {})
 
     assert_template_result('true',
-                           '{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
-                           {})
+      '{% case true %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+      {})
 
     assert_template_result('else',
-                           '{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
-                           {})
+      '{% case NULL %}{% when true %}true{% when false %}false{% else %}else{% endcase %}',
+      {})
   end
 
   def test_assign_from_case
     # Example from the shopify forums
-    code = %q({% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }})
+    code = "{% case collection.handle %}{% when 'menswear-jackets' %}{% assign ptitle = 'menswear' %}{% when 'menswear-t-shirts' %}{% assign ptitle = 'menswear' %}{% else %}{% assign ptitle = 'womenswear' %}{% endcase %}{{ ptitle }}"
     template = Liquid::Template.parse(code)
-    assert_equal "menswear",   template.render!("collection" => {'handle' => 'menswear-jackets'})
-    assert_equal "menswear",   template.render!("collection" => {'handle' => 'menswear-t-shirts'})
-    assert_equal "womenswear", template.render!("collection" => {'handle' => 'x'})
-    assert_equal "womenswear", template.render!("collection" => {'handle' => 'y'})
-    assert_equal "womenswear", template.render!("collection" => {'handle' => 'z'})
+    assert_equal "menswear",   template.render!("collection" => { 'handle' => 'menswear-jackets' })
+    assert_equal "menswear",   template.render!("collection" => { 'handle' => 'menswear-t-shirts' })
+    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'x' })
+    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'y' })
+    assert_equal "womenswear", template.render!("collection" => { 'handle' => 'z' })
   end
 
   def test_case_when_or
     code = '{% case condition %}{% when 1 or 2 or 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 2 })
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 3 })
-    assert_template_result(' its 4 ', code, {'condition' => 4 })
-    assert_template_result('', code, {'condition' => 5 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
+    assert_template_result(' its 4 ', code, { 'condition' => 4 })
+    assert_template_result('', code, { 'condition' => 5 })
 
     code = '{% case condition %}{% when 1 or "string" or null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 'string' })
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => nil })
-    assert_template_result('', code, {'condition' => 'something else' })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
+    assert_template_result('', code, { 'condition' => 'something else' })
   end
 
   def test_case_when_comma
     code = '{% case condition %}{% when 1, 2, 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 2 })
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 3 })
-    assert_template_result(' its 4 ', code, {'condition' => 4 })
-    assert_template_result('', code, {'condition' => 5 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
+    assert_template_result(' its 4 ', code, { 'condition' => 4 })
+    assert_template_result('', code, { 'condition' => 5 })
 
     code = '{% case condition %}{% when 1, "string", null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => 'string' })
-    assert_template_result(' its 1 or 2 or 3 ', code, {'condition' => nil })
-    assert_template_result('', code, {'condition' => 'something else' })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
+    assert_template_result('', code, { 'condition' => 'something else' })
   end
 
   def test_assign
@@ -236,15 +236,14 @@ class StandardTagTest < Minitest::Test
     assert_raises(SyntaxError) do
       assert_template_result('',  '{% case false %}{% huh %}true{% endcase %}', {})
     end
-
   end
 
   def test_cycle
-    assert_template_result('one','{%cycle "one", "two"%}')
-    assert_template_result('one two','{%cycle "one", "two"%} {%cycle "one", "two"%}')
-    assert_template_result(' two','{%cycle "", "two"%} {%cycle "", "two"%}')
+    assert_template_result('one', '{%cycle "one", "two"%}')
+    assert_template_result('one two', '{%cycle "one", "two"%} {%cycle "one", "two"%}')
+    assert_template_result(' two', '{%cycle "", "two"%} {%cycle "", "two"%}')
 
-    assert_template_result('one two one','{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}')
+    assert_template_result('one two one', '{%cycle "one", "two"%} {%cycle "one", "two"%} {%cycle "one", "two"%}')
 
     assert_template_result('text-align: left text-align: right',
       '{%cycle "text-align: left", "text-align: right" %} {%cycle "text-align: left", "text-align: right"%}')
@@ -261,18 +260,18 @@ class StandardTagTest < Minitest::Test
   end
 
   def test_multiple_named_cycles_with_names_from_context
-    assigns = {"var1" => 1, "var2" => 2 }
+    assigns = { "var1" => 1, "var2" => 2 }
     assert_template_result('one one two two one one',
       '{%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %} {%cycle var1: "one", "two" %} {%cycle var2: "one", "two" %}', assigns)
   end
 
   def test_size_of_array
-    assigns = {"array" => [1,2,3,4]}
+    assigns = { "array" => [1, 2, 3, 4] }
     assert_template_result('array has 4 elements', "array has {{ array.size }} elements", assigns)
   end
 
   def test_size_of_hash
-    assigns = {"hash" => {:a => 1, :b => 2, :c=> 3, :d => 4}}
+    assigns = { "hash" => { a: 1, b: 2, c: 3, d: 4 } }
     assert_template_result('hash has 4 elements', "hash has {{ hash.size }} elements", assigns)
   end
 
@@ -284,11 +283,11 @@ class StandardTagTest < Minitest::Test
   end
 
   def test_ifchanged
-    assigns = {'array' => [ 1, 1, 2, 2, 3, 3] }
-    assert_template_result('123','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
+    assigns = { 'array' => [ 1, 1, 2, 2, 3, 3] }
+    assert_template_result('123', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
 
-    assigns = {'array' => [ 1, 1, 1, 1] }
-    assert_template_result('1','{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}',assigns)
+    assigns = { 'array' => [ 1, 1, 1, 1] }
+    assert_template_result('1', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
   end
 
   def test_multiline_tag

test/integration/tags/statements_test.rb

@@ -37,7 +37,6 @@ class StatementsTest < Minitest::Test
     text = ' {% if null <= 0 %} true {% else %} false {% endif %} '
     assert_template_result '  false  ', text
 
-
     text = ' {% if 0 <= null %} true {% else %} false {% endif %} '
     assert_template_result '  false  ', text
   end
@@ -72,18 +71,17 @@ class StatementsTest < Minitest::Test
     assert_template_result '  true  ', text, 'var' => 'hello there!'
   end
 
-
   def test_var_and_long_string_are_equal_backwards
     text = " {% if 'hello there!' == var %} true {% else %} false {% endif %} "
     assert_template_result '  true  ', text, 'var' => 'hello there!'
   end
 
-  #def test_is_nil
+  # def test_is_nil
   #  text = %| {% if var != nil %} true {% else %} false {% end %} |
   #  @template.assigns = { 'var' => 'hello there!'}
   #  expected = %|  true  |
   #  assert_equal expected, @template.parse(text)
-  #end
+  # end
 
   def test_is_collection_empty
     text = ' {% if array == empty %} true {% else %} false {% endif %} '
@@ -92,7 +90,7 @@ class StatementsTest < Minitest::Test
 
   def test_is_not_collection_empty
     text = ' {% if array == empty %} true {% else %} false {% endif %} '
-    assert_template_result '  false  ', text, 'array' => [1,2,3]
+    assert_template_result '  false  ', text, 'array' => [1, 2, 3]
   end
 
   def test_nil

test/integration/tags/table_row_test.rb

@@ -16,48 +16,49 @@ class TableRowTest < Minitest::Test
   end
 
   def test_table_row
-
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
-                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-                           'numbers' => [1,2,3,4,5,6])
+      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
+      'numbers' => [1, 2, 3, 4, 5, 6])
 
     assert_template_result("<tr class=\"row1\">\n</tr>\n",
-                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-                           'numbers' => [])
+      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
+      'numbers' => [])
   end
 
   def test_table_row_with_different_cols
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td><td class=\"col4\"> 4 </td><td class=\"col5\"> 5 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 6 </td></tr>\n",
-                           '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
-                           'numbers' => [1,2,3,4,5,6])
-
+      '{% tablerow n in numbers cols:5%} {{n}} {% endtablerow %}',
+      'numbers' => [1, 2, 3, 4, 5, 6])
   end
 
   def test_table_col_counter
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row2\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n<tr class=\"row3\"><td class=\"col1\">1</td><td class=\"col2\">2</td></tr>\n",
-                           '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
-                           'numbers' => [1,2,3,4,5,6])
+      '{% tablerow n in numbers cols:2%}{{tablerowloop.col}}{% endtablerow %}',
+      'numbers' => [1, 2, 3, 4, 5, 6])
   end
 
   def test_quoted_fragment
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
-                           "{% tablerow n in collections.frontpage cols:3%} {{n}} {% endtablerow %}",
-                           'collections' => {'frontpage' => [1,2,3,4,5,6]})
+      "{% tablerow n in collections.frontpage cols:3%} {{n}} {% endtablerow %}",
+      'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
-                           "{% tablerow n in collections['frontpage'] cols:3%} {{n}} {% endtablerow %}",
-                           'collections' => {'frontpage' => [1,2,3,4,5,6]})
-
+      "{% tablerow n in collections['frontpage'] cols:3%} {{n}} {% endtablerow %}",
+      'collections' => { 'frontpage' => [1, 2, 3, 4, 5, 6] })
   end
 
   def test_enumerable_drop
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
-                           '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
-                           'numbers' => ArrayDrop.new([1,2,3,4,5,6]))
+      '{% tablerow n in numbers cols:3%} {{n}} {% endtablerow %}',
+      'numbers' => ArrayDrop.new([1, 2, 3, 4, 5, 6]))
   end
 
   def test_offset_and_limit
     assert_template_result("<tr class=\"row1\">\n<td class=\"col1\"> 1 </td><td class=\"col2\"> 2 </td><td class=\"col3\"> 3 </td></tr>\n<tr class=\"row2\"><td class=\"col1\"> 4 </td><td class=\"col2\"> 5 </td><td class=\"col3\"> 6 </td></tr>\n",
-                           '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
-                           'numbers' => [0,1,2,3,4,5,6,7])
+      '{% tablerow n in numbers cols:3 offset:1 limit:6%} {{n}} {% endtablerow %}',
+      'numbers' => [0, 1, 2, 3, 4, 5, 6, 7])
+  end
+
+  def test_blank_string_not_iterable
+    assert_template_result("<tr class=\"row1\">\n</tr>\n", "{% tablerow char in characters cols:3 %}I WILL NOT BE OUTPUT{% endtablerow %}", 'characters' => '')
   end
 end

test/integration/tags/unless_else_tag_test.rb

@@ -4,16 +4,16 @@ class UnlessElseTagTest < Minitest::Test
   include Liquid
 
   def test_unless
-    assert_template_result('  ',' {% unless true %} this text should not go into the output {% endunless %} ')
+    assert_template_result('  ', ' {% unless true %} this text should not go into the output {% endunless %} ')
     assert_template_result('  this text should go into the output  ',
-                           ' {% unless false %} this text should go into the output {% endunless %} ')
-    assert_template_result('  you rock ?','{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
+      ' {% unless false %} this text should go into the output {% endunless %} ')
+    assert_template_result('  you rock ?', '{% unless true %} you suck {% endunless %} {% unless false %} you rock {% endunless %}?')
   end
 
   def test_unless_else
-    assert_template_result(' YES ','{% unless true %} NO {% else %} YES {% endunless %}')
-    assert_template_result(' YES ','{% unless false %} YES {% else %} NO {% endunless %}')
-    assert_template_result(' YES ','{% unless "foo" %} NO {% else %} YES {% endunless %}')
+    assert_template_result(' YES ', '{% unless true %} NO {% else %} YES {% endunless %}')
+    assert_template_result(' YES ', '{% unless false %} YES {% else %} NO {% endunless %}')
+    assert_template_result(' YES ', '{% unless "foo" %} NO {% else %} YES {% endunless %}')
   end
 
   def test_unless_in_loop

test/integration/template_test.rb

@@ -15,12 +15,10 @@ class TemplateContextDrop < Liquid::Drop
   end
 end
 
-class SomethingWithLength
+class SomethingWithLength < Liquid::Drop
   def length
     nil
   end
-
-  liquid_methods :length
 end
 
 class ErroneousDrop < Liquid::Drop
@@ -45,7 +43,7 @@ class TemplateTest < Minitest::Test
     end
 
     t = Template.parse(str)
-    assert_equal [], Timeout::timeout(1) { t.warnings }
+    assert_equal [], Timeout.timeout(1) { t.warnings }
   end
 
   def test_instance_assigns_persist_on_same_template_parsing_between_renders
@@ -75,7 +73,7 @@ class TemplateTest < Minitest::Test
 
   def test_lambda_is_called_once_from_persistent_assigns_over_multiple_parses_and_renders
     t = Template.new
-    t.assigns['number'] = lambda { @global ||= 0; @global += 1 }
+    t.assigns['number'] = -> { @global ||= 0; @global += 1 }
     assert_equal '1', t.parse("{{number}}").render!
     assert_equal '1', t.parse("{{number}}").render!
     assert_equal '1', t.render!
@@ -84,7 +82,7 @@ class TemplateTest < Minitest::Test
 
   def test_lambda_is_called_once_from_custom_assigns_over_multiple_parses_and_renders
     t = Template.new
-    assigns = {'number' => lambda { @global ||= 0; @global += 1 }}
+    assigns = { 'number' => -> { @global ||= 0; @global += 1 } }
     assert_equal '1', t.parse("{{number}}").render!(assigns)
     assert_equal '1', t.parse("{{number}}").render!(assigns)
     assert_equal '1', t.render!(assigns)
@@ -100,51 +98,51 @@ class TemplateTest < Minitest::Test
   def test_resource_limits_render_length
     t = Template.parse("0123456789")
     t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     assert t.resource_limits.reached?
 
     t.resource_limits.render_length_limit = 10
-    assert_equal "0123456789", t.render!()
+    assert_equal "0123456789", t.render!
     refute_nil t.resource_limits.render_length
   end
 
   def test_resource_limits_render_score
     t = Template.parse("{% for a in (1..10) %} {% for a in (1..10) %} foo {% endfor %} {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     assert t.resource_limits.reached?
 
     t = Template.parse("{% for a in (1..100) %} foo {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     assert t.resource_limits.reached?
 
     t.resource_limits.render_score_limit = 200
-    assert_equal (" foo " * 100), t.render!()
+    assert_equal (" foo " * 100), t.render!
     refute_nil t.resource_limits.render_score
   end
 
   def test_resource_limits_assign_score
     t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
     t.resource_limits.assign_score_limit = 1
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     assert t.resource_limits.reached?
 
     t.resource_limits.assign_score_limit = 2
-    assert_equal "", t.render!()
+    assert_equal "", t.render!
     refute_nil t.resource_limits.assign_score
   end
 
   def test_resource_limits_aborts_rendering_after_first_error
     t = Template.parse("{% for a in (1..100) %} foo1 {% endfor %} bar {% for a in (1..100) %} foo2 {% endfor %}")
     t.resource_limits.render_score_limit = 50
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     assert t.resource_limits.reached?
   end
 
   def test_resource_limits_hash_in_template_gets_updated_even_if_no_limits_are_set
     t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
-    t.render!()
+    t.render!
     assert t.resource_limits.assign_score > 0
     assert t.resource_limits.render_score > 0
     assert t.resource_limits.render_length > 0
@@ -153,23 +151,23 @@ class TemplateTest < Minitest::Test
   def test_render_length_persists_between_blocks
     t = Template.parse("{% if true %}aaaa{% endif %}")
     t.resource_limits.render_length_limit = 7
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     t.resource_limits.render_length_limit = 8
-    assert_equal "aaaa", t.render()
+    assert_equal "aaaa", t.render
 
     t = Template.parse("{% if true %}aaaa{% endif %}{% if true %}bbb{% endif %}")
     t.resource_limits.render_length_limit = 13
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     t.resource_limits.render_length_limit = 14
-    assert_equal "aaaabbb", t.render()
+    assert_equal "aaaabbb", t.render
 
     t = Template.parse("{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}{% if true %}a{% endif %}{% if true %}b{% endif %}")
     t.resource_limits.render_length_limit = 5
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     t.resource_limits.render_length_limit = 11
-    assert_equal "Liquid error: Memory limits exceeded", t.render()
+    assert_equal "Liquid error: Memory limits exceeded", t.render
     t.resource_limits.render_length_limit = 12
-    assert_equal "ababab", t.render()
+    assert_equal "ababab", t.render
   end
 
   def test_default_resource_limits_unaffected_by_render_with_context
@@ -191,7 +189,7 @@ class TemplateTest < Minitest::Test
   end
 
   def test_render_bang_force_rethrow_errors_on_passed_context
-    context = Context.new({'drop' => ErroneousDrop.new})
+    context = Context.new({ 'drop' => ErroneousDrop.new })
     t = Template.new.parse('{{ drop.bad_method }}')
 
     e = assert_raises RuntimeError do
@@ -203,14 +201,14 @@ class TemplateTest < Minitest::Test
   def test_exception_handler_doesnt_reraise_if_it_returns_false
     exception = nil
     Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; false })
-    assert exception.is_a?(ZeroDivisionError)
+    assert exception.is_a?(Liquid::ZeroDivisionError)
   end
 
   def test_exception_handler_does_reraise_if_it_returns_true
     exception = nil
-    assert_raises(ZeroDivisionError) do
+    assert_raises(Liquid::ZeroDivisionError) do
       Template.parse("{{ 1 | divided_by: 0 }}").render({}, exception_handler: ->(e) { exception = e; true })
     end
-    assert exception.is_a?(ZeroDivisionError)
+    assert exception.is_a?(Liquid::ZeroDivisionError)
   end
 end

test/integration/variable_test.rb

@@ -4,7 +4,7 @@ class VariableTest < Minitest::Test
   include Liquid
 
   def test_simple_variable
-    template = Template.parse(%|{{test}}|)
+    template = Template.parse(%({{test}}))
     assert_equal 'worked', template.render!('test' => 'worked')
     assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
   end
@@ -14,19 +14,29 @@ class VariableTest < Minitest::Test
   end
 
   def test_simple_with_whitespaces
-    template = Template.parse(%|  {{ test }}  |)
+    template = Template.parse(%(  {{ test }}  ))
     assert_equal '  worked  ', template.render!('test' => 'worked')
     assert_equal '  worked wonderfully  ', template.render!('test' => 'worked wonderfully')
   end
 
   def test_ignore_unknown
-    template = Template.parse(%|{{ test }}|)
+    template = Template.parse(%({{ test }}))
+    assert_equal '', template.render!
+  end
+
+  def test_using_blank_as_variable_name
+    template = Template.parse("{% assign foo = blank %}{{ foo }}")
+    assert_equal '', template.render!
+  end
+
+  def test_using_empty_as_variable_name
+    template = Template.parse("{% assign foo = empty %}{{ foo }}")
     assert_equal '', template.render!
   end
 
   def test_hash_scoping
-    template = Template.parse(%|{{ test.test }}|)
-    assert_equal 'worked', template.render!('test' => {'test' => 'worked'})
+    template = Template.parse(%({{ test.test }}))
+    assert_equal 'worked', template.render!('test' => { 'test' => 'worked' })
   end
 
   def test_false_renders_as_false
@@ -40,23 +50,23 @@ class VariableTest < Minitest::Test
   end
 
   def test_preset_assigns
-    template = Template.parse(%|{{ test }}|)
+    template = Template.parse(%({{ test }}))
     template.assigns['test'] = 'worked'
     assert_equal 'worked', template.render!
   end
 
   def test_reuse_parsed_template
-    template = Template.parse(%|{{ greeting }} {{ name }}|)
+    template = Template.parse(%({{ greeting }} {{ name }}))
     template.assigns['greeting'] = 'Goodbye'
     assert_equal 'Hello Tobi', template.render!('greeting' => 'Hello', 'name' => 'Tobi')
     assert_equal 'Hello ', template.render!('greeting' => 'Hello', 'unknown' => 'Tobi')
     assert_equal 'Hello Brian', template.render!('greeting' => 'Hello', 'name' => 'Brian')
     assert_equal 'Goodbye Brian', template.render!('name' => 'Brian')
-    assert_equal({'greeting'=>'Goodbye'}, template.assigns)
+    assert_equal({ 'greeting' => 'Goodbye' }, template.assigns)
   end
 
   def test_assigns_not_polluted_from_template
-    template = Template.parse(%|{{ test }}{% assign test = 'bar' %}{{ test }}|)
+    template = Template.parse(%({{ test }}{% assign test = 'bar' %}{{ test }}))
     template.assigns['test'] = 'baz'
     assert_equal 'bazbar', template.render!
     assert_equal 'bazbar', template.render!
@@ -65,18 +75,46 @@ class VariableTest < Minitest::Test
   end
 
   def test_hash_with_default_proc
-    template = Template.parse(%|Hello {{ test }}|)
-    assigns = Hash.new { |h,k| raise "Unknown variable '#{k}'" }
+    template = Template.parse(%(Hello {{ test }}))
+    assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" }
     assigns['test'] = 'Tobi'
     assert_equal 'Hello Tobi', template.render!(assigns)
     assigns.delete('test')
-    e = assert_raises(RuntimeError) {
+    e = assert_raises(RuntimeError) do
       template.render!(assigns)
-    }
+    end
     assert_equal "Unknown variable 'test'", e.message
   end
 
   def test_multiline_variable
     assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
   end
+
+  def test_lax_warnings_for_variable_ignored_prefix
+    ignored_chars = %(|,'")
+    template = Liquid::Template.parse("{{ #{ignored_chars}test }}", error_mode: :lax_warn)
+    assert_equal "works", template.render!('test' => 'works')
+    assert_equal [Liquid::SyntaxError.new("variable prefixed with ignored characters: #{ignored_chars.inspect}")], template.warnings
+  end
+
+  def test_lax_warnings_for_ignored_variable_filter_prefix
+    ignored_chars = ",wat? lax!"
+    template = Liquid::Template.parse("{{ test#{ignored_chars} | noop }}", error_mode: :lax_warn)
+    assert_equal "works", template.render!('test' => 'works')
+    assert_equal [Liquid::SyntaxError.new("variable filter separator prefixed with ignored characters: #{ignored_chars.inspect}")], template.warnings
+  end
+
+  def test_lax_warnings_for_weird_filter_chars
+    template = Liquid::Template.parse("{{ test | upcase \" prepend: 'it ' || append: ' surprisingly' }}", error_mode: :lax_warn)
+    assert_equal "it WORKS surprisingly", template.render!('test' => 'works')
+    expected_warnings = ['"', '||'].map{ |sep| Liquid::SyntaxError.new("unterminated quote or multiple pipe characters used as a filter separator: #{sep.inspect}") }
+    assert_equal expected_warnings, template.warnings
+  end
+
+  def test_lax_warnings_for_ignored_filter_name_prefix
+    ignored_chars = "'': '"
+    template = Liquid::Template.parse("{{ test | '': 'prepend ' }}", error_mode: :lax_warn)
+    assert_equal "prepend wat", template.render!('test' => 'wat')
+    assert_equal [Liquid::SyntaxError.new("ignored characters before filter name: #{ignored_chars.inspect}")], template.warnings
+  end
 end

test/test_helper.rb

@@ -4,7 +4,7 @@ ENV["MT_NO_EXPECTATIONS"] = "1"
 require 'minitest/autorun'
 require 'spy/integration'
 
-$:.unshift(File.join(File.expand_path(File.dirname(__FILE__)), '..', 'lib'))
+$LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
 require 'liquid.rb'
 require 'liquid/profiler'
 
@@ -15,6 +15,11 @@ if env_mode = ENV['LIQUID_PARSER_MODE']
 end
 Liquid::Template.error_mode = mode
 
+if ENV['LIQUID-C'] == '1'
+  puts "-- LIQUID C"
+  require 'liquid/c'
+end
+
 if Minitest.const_defined?('Test')
   # We're on Minitest 5+. Nothing to do here.
 else
@@ -25,7 +30,7 @@ end
 module Minitest
   class Test
     def fixture(name)
-      File.join(File.expand_path(File.dirname(__FILE__)), "fixtures", name)
+      File.join(File.expand_path(__dir__), "fixtures", name)
     end
   end
 
@@ -33,19 +38,19 @@ module Minitest
     include Liquid
 
     def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template).render!(assigns)
+      assert_equal expected, Template.parse(template).render!(assigns), message
     end
 
     def assert_template_result_matches(expected, template, assigns = {}, message = nil)
       return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
 
-      assert_match expected, Template.parse(template).render!(assigns)
+      assert_match expected, Template.parse(template).render!(assigns), message
     end
 
-    def assert_match_syntax_error(match, template, registers = {})
-      exception = assert_raises(Liquid::SyntaxError) {
+    def assert_match_syntax_error(match, template, assigns = {})
+      exception = assert_raises(Liquid::SyntaxError) do
         Template.parse(template).render(assigns)
-      }
+      end
       assert_match match, exception.message
     end
 
@@ -88,3 +93,25 @@ class ThingWithToLiquid
     'foobar'
   end
 end
+
+class ErrorDrop < Liquid::Drop
+  def standard_error
+    raise Liquid::StandardError, 'standard error'
+  end
+
+  def argument_error
+    raise Liquid::ArgumentError, 'argument error'
+  end
+
+  def syntax_error
+    raise Liquid::SyntaxError, 'syntax error'
+  end
+
+  def runtime_error
+    raise 'runtime error'
+  end
+
+  def exception
+    raise Exception, 'exception'
+  end
+end

test/unit/block_unit_test.rb

@@ -34,7 +34,7 @@ class BlockUnitTest < Minitest::Test
     template = Liquid::Template.parse("  {{funk}} {{so}} {{brother}} ")
     assert_equal 7, template.root.nodelist.size
     assert_equal [String, Variable, String, Variable, String, Variable, String],
-                 block_types(template.root.nodelist)
+      block_types(template.root.nodelist)
   end
 
   def test_with_block
@@ -45,11 +45,12 @@ class BlockUnitTest < Minitest::Test
 
   def test_with_custom_tag
     Liquid::Template.register_tag("testtag", Block)
-    assert Liquid::Template.parse( "{% testtag %} {% endtesttag %}")
+    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
   end
 
   private
-    def block_types(nodelist)
-      nodelist.collect { |node| node.class }
-    end
+
+  def block_types(nodelist)
+    nodelist.collect(&:class)
+  end
 end # VariableTest

test/unit/condition_unit_test.rb

@@ -62,15 +62,15 @@ class ConditionUnitTest < Minitest::Test
 
   def test_contains_works_on_arrays
     @context = Liquid::Context.new
-    @context['array'] = [1,2,3,4,5]
+    @context['array'] = [1, 2, 3, 4, 5]
     array_expr = VariableLookup.new("array")
 
     assert_evalutes_false array_expr, 'contains', 0
-    assert_evalutes_true  array_expr, 'contains', 1
-    assert_evalutes_true  array_expr, 'contains', 2
-    assert_evalutes_true  array_expr, 'contains', 3
-    assert_evalutes_true  array_expr, 'contains', 4
-    assert_evalutes_true  array_expr, 'contains', 5
+    assert_evalutes_true array_expr, 'contains', 1
+    assert_evalutes_true array_expr, 'contains', 2
+    assert_evalutes_true array_expr, 'contains', 3
+    assert_evalutes_true array_expr, 'contains', 4
+    assert_evalutes_true array_expr, 'contains', 5
     assert_evalutes_false array_expr, 'contains', 6
     assert_evalutes_false array_expr, 'contains', "1"
   end
@@ -85,6 +85,11 @@ class ConditionUnitTest < Minitest::Test
     assert_evalutes_false 1, 'contains', 0
   end
 
+  def test_contains_with_string_left_operand_coerces_right_operand_to_string
+    assert_evalutes_true ' 1 ', 'contains', 1
+    assert_evalutes_false ' 1 ', 'contains', 2
+  end
+
   def test_or_condition
     condition = Condition.new(1, '==', 2)
 
@@ -114,9 +119,9 @@ class ConditionUnitTest < Minitest::Test
   end
 
   def test_should_allow_custom_proc_operator
-    Condition.operators['starts_with'] = Proc.new { |cond, left, right| left =~ %r{^#{right}} }
+    Condition.operators['starts_with'] = proc { |cond, left, right| left =~ %r{^#{right}} }
 
-    assert_evalutes_true  'bob', 'starts_with', 'b'
+    assert_evalutes_true 'bob', 'starts_with', 'b'
     assert_evalutes_false 'bob', 'starts_with', 'o'
   ensure
     Condition.operators.delete 'starts_with'
@@ -130,20 +135,20 @@ class ConditionUnitTest < Minitest::Test
   end
 
   private
-    def assert_evalutes_true(left, op, right)
-      assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
-             "Evaluated false: #{left} #{op} #{right}"
-    end
 
-    def assert_evalutes_false(left, op, right)
-      assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
-             "Evaluated true: #{left} #{op} #{right}"
-    end
+  def assert_evalutes_true(left, op, right)
+    assert Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
+      "Evaluated false: #{left} #{op} #{right}"
+  end
 
-    def assert_evaluates_argument_error(left, op, right)
-      assert_raises(Liquid::ArgumentError) do
-        Condition.new(left, op, right).evaluate(@context || Liquid::Context.new)
-      end
-    end
+  def assert_evalutes_false(left, op, right)
+    assert !Condition.new(left, op, right).evaluate(@context || Liquid::Context.new),
+      "Evaluated true: #{left} #{op} #{right}"
+  end
 
+  def assert_evaluates_argument_error(left, op, right)
+    assert_raises(Liquid::ArgumentError) do
+      Condition.new(left, op, right).evaluate(@context || Liquid::Context.new)
+    end
+  end
 end # ConditionTest

test/unit/context_unit_test.rb

@@ -122,30 +122,25 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_length_query
-
-    @context['numbers'] = [1,2,3,4]
+    @context['numbers'] = [1, 2, 3, 4]
 
     assert_equal 4, @context['numbers.size']
 
-    @context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4}
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
 
     assert_equal 4, @context['numbers.size']
 
-    @context['numbers'] = {1 => 1,2 => 2,3 => 3,4 => 4, 'size' => 1000}
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
 
     assert_equal 1000, @context['numbers.size']
-
   end
 
   def test_hyphenated_variable
-
     @context['oh-my'] = 'godz'
     assert_equal 'godz', @context['oh-my']
-
   end
 
   def test_add_filter
-
     filter = Module.new do
       def hi(output)
         output + ' hi!'
@@ -161,11 +156,9 @@ class ContextUnitTest < Minitest::Test
 
     context.add_filters(filter)
     assert_equal 'hi? hi!', context.invoke(:hi, 'hi?')
-
   end
 
   def test_only_intended_filters_make_it_there
-
     filter = Module.new do
       def hi(output)
         output + ' hi!'
@@ -196,7 +189,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_hierachical_data
-    @context['hash'] = {"name" => 'tobi'}
+    @context['hash'] = { "name" => 'tobi' }
     assert_equal 'tobi', @context['hash.name']
     assert_equal 'tobi', @context['hash["name"]']
   end
@@ -225,7 +218,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_array_notation
-    @context['test'] = [1,2,3,4,5]
+    @context['test'] = [1, 2, 3, 4, 5]
 
     assert_equal 1, @context['test[0]']
     assert_equal 2, @context['test[1]']
@@ -235,21 +228,21 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_recoursive_array_notation
-    @context['test'] = {'test' => [1,2,3,4,5]}
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
 
     assert_equal 1, @context['test.test[0]']
 
-    @context['test'] = [{'test' => 'worked'}]
+    @context['test'] = [{ 'test' => 'worked' }]
 
     assert_equal 'worked', @context['test[0].test']
   end
 
   def test_hash_to_array_transition
     @context['colors'] = {
-      'Blue'    => ['003366','336699', '6699CC', '99CCFF'],
-      'Green'   => ['003300','336633', '669966', '99CC99'],
-      'Yellow'  => ['CC9900','FFCC00', 'FFFF99', 'FFFFCC'],
-      'Red'     => ['660000','993333', 'CC6666', 'FF9999']
+      'Blue'    => ['003366', '336699', '6699CC', '99CCFF'],
+      'Green'   => ['003300', '336633', '669966', '99CC99'],
+      'Yellow'  => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
+      'Red'     => ['660000', '993333', 'CC6666', 'FF9999']
     }
 
     assert_equal '003366', @context['colors.Blue[0]']
@@ -257,12 +250,12 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_try_first
-    @context['test'] = [1,2,3,4,5]
+    @context['test'] = [1, 2, 3, 4, 5]
 
     assert_equal 1, @context['test.first']
     assert_equal 5, @context['test.last']
 
-    @context['test'] = {'test' => [1,2,3,4,5]}
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
 
     assert_equal 1, @context['test.test.first']
     assert_equal 5, @context['test.test.last']
@@ -273,8 +266,8 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_access_hashes_with_hash_notation
-    @context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
-    @context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'}  ]}
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' }  ] }
 
     assert_equal 5, @context['products["count"]']
     assert_equal 'deepsnow', @context['products["tags"][0]']
@@ -294,18 +287,17 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_access_hashes_with_hash_access_variables
-
     @context['var'] = 'tags'
-    @context['nested'] = {'var' => 'tags'}
-    @context['products'] = {'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['nested'] = { 'var' => 'tags' }
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
 
     assert_equal 'deepsnow', @context['products[var].first']
     assert_equal 'freestyle', @context['products[nested.var].last']
   end
 
   def test_hash_notation_only_for_hash_access
-    @context['array'] = [1,2,3,4,5]
-    @context['hash'] = {'first' => 'Hello'}
+    @context['array'] = [1, 2, 3, 4, 5]
+    @context['hash'] = { 'first' => 'Hello' }
 
     assert_equal 1, @context['array.first']
     assert_equal nil, @context['array["first"]']
@@ -313,66 +305,64 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_first_can_appear_in_middle_of_callchain
-
-    @context['product'] = {'variants' => [ {'title' => 'draft151cm'}, {'title' => 'element151cm'}  ]}
+    @context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' }  ] }
 
     assert_equal 'draft151cm', @context['product.variants[0].title']
     assert_equal 'element151cm', @context['product.variants[1].title']
     assert_equal 'draft151cm', @context['product.variants.first.title']
     assert_equal 'element151cm', @context['product.variants.last.title']
-
   end
 
   def test_cents
-    @context.merge( "cents" => HundredCentes.new )
+    @context.merge("cents" => HundredCentes.new)
     assert_equal 100, @context['cents']
   end
 
   def test_nested_cents
-    @context.merge( "cents" => { 'amount' => HundredCentes.new} )
+    @context.merge("cents" => { 'amount' => HundredCentes.new })
     assert_equal 100, @context['cents.amount']
 
-    @context.merge( "cents" => { 'cents' => { 'amount' => HundredCentes.new} } )
+    @context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
     assert_equal 100, @context['cents.cents.amount']
   end
 
   def test_cents_through_drop
-    @context.merge( "cents" => CentsDrop.new )
+    @context.merge("cents" => CentsDrop.new)
     assert_equal 100, @context['cents.amount']
   end
 
   def test_nested_cents_through_drop
-    @context.merge( "vars" => {"cents" => CentsDrop.new} )
+    @context.merge("vars" => { "cents" => CentsDrop.new })
     assert_equal 100, @context['vars.cents.amount']
   end
 
   def test_drop_methods_with_question_marks
-    @context.merge( "cents" => CentsDrop.new )
+    @context.merge("cents" => CentsDrop.new)
     assert @context['cents.non_zero?']
   end
 
   def test_context_from_within_drop
-    @context.merge( "test" => '123', "vars" => ContextSensitiveDrop.new )
+    @context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
     assert_equal '123', @context['vars.test']
   end
 
   def test_nested_context_from_within_drop
-    @context.merge( "test" => '123', "vars" => {"local" => ContextSensitiveDrop.new }  )
+    @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
     assert_equal '123', @context['vars.local.test']
   end
 
   def test_ranges
-    @context.merge( "test" => '5' )
+    @context.merge("test" => '5')
     assert_equal (1..5), @context['(1..5)']
     assert_equal (1..5), @context['(1..test)']
     assert_equal (5..5), @context['(test..test)']
   end
 
   def test_cents_through_drop_nestedly
-    @context.merge( "cents" => {"cents" => CentsDrop.new} )
+    @context.merge("cents" => { "cents" => CentsDrop.new })
     assert_equal 100, @context['cents.cents.amount']
 
-    @context.merge( "cents" => { "cents" => {"cents" => CentsDrop.new}} )
+    @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
     assert_equal 100, @context['cents.cents.cents.amount']
   end
 
@@ -393,7 +383,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_proc_as_variable
-    @context['dynamic'] = Proc.new { 'Hello' }
+    @context['dynamic'] = proc { 'Hello' }
 
     assert_equal 'Hello', @context['dynamic']
   end
@@ -411,7 +401,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_array_containing_lambda_as_variable
-    @context['dynamic'] = [1,2, proc { 'Hello' } ,4,5]
+    @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
 
     assert_equal 'Hello', @context['dynamic[2]']
   end
@@ -437,7 +427,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_lambda_in_array_is_called_once
-    @context['callcount'] = [1,2, proc { @global ||= 0; @global += 1; @global.to_s } ,4,5]
+    @context['callcount'] = [1, 2, proc { @global ||= 0; @global += 1; @global.to_s }, 4, 5]
 
     assert_equal '1', @context['callcount[2]']
     assert_equal '1', @context['callcount[2]']
@@ -463,21 +453,17 @@ class ContextUnitTest < Minitest::Test
   def test_use_empty_instead_of_any_in_interrupt_handling_to_avoid_lots_of_unnecessary_object_allocations
     mock_any = Spy.on_instance_method(Array, :any?)
     mock_empty = Spy.on_instance_method(Array, :empty?)
-    mock_has_interrupt = Spy.on(@context, :has_interrupt?).and_call_through
 
-    @context.push_interrupt(StandardError.new)
-    @context.has_interrupt?
+    @context.interrupt?
 
     refute mock_any.has_been_called?
     assert mock_empty.has_been_called?
   end
 
   def test_context_initialization_with_a_proc_in_environment
-    contx = Context.new([:test => lambda { |c| c['poutine']}], {:test => :foo})
+    contx = Context.new([test: ->(c) { c['poutine'] }], { test: :foo })
 
     assert contx
     assert_nil contx['poutine']
   end
-
-
 end # ContextTest

test/unit/file_system_unit_test.rb

@@ -11,7 +11,7 @@ class FileSystemUnitTest < Minitest::Test
 
   def test_local
     file_system = Liquid::LocalFileSystem.new("/some/path")
-    assert_equal "/some/path/_mypartial.liquid"    , file_system.full_path("mypartial")
+    assert_equal "/some/path/_mypartial.liquid", file_system.full_path("mypartial")
     assert_equal "/some/path/dir/_mypartial.liquid", file_system.full_path("dir/mypartial")
 
     assert_raises(FileSystemError) do
@@ -29,7 +29,7 @@ class FileSystemUnitTest < Minitest::Test
 
   def test_custom_template_filename_patterns
     file_system = Liquid::LocalFileSystem.new("/some/path", "%s.html")
-    assert_equal "/some/path/mypartial.html"    , file_system.full_path("mypartial")
+    assert_equal "/some/path/mypartial.html", file_system.full_path("mypartial")
     assert_equal "/some/path/dir/mypartial.html", file_system.full_path("dir/mypartial")
   end
 end # FileSystemTest

test/unit/i18n_unit_test.rb

@@ -16,7 +16,7 @@ class I18nUnitTest < Minitest::Test
   end
 
   def test_single_string_interpolation
-    assert_equal "something different", @i18n.translate("whatever", :something => "different")
+    assert_equal "something different", @i18n.translate("whatever", something: "different")
   end
 
   # def test_raises_translation_error_on_undefined_interpolation_key
@@ -24,7 +24,7 @@ class I18nUnitTest < Minitest::Test
   #     @i18n.translate("whatever", :oopstypos => "yes")
   #   end
   # end
-  
+
   def test_raises_unknown_translation
     assert_raises I18n::TranslationError do
       @i18n.translate("doesnt_exist")

test/unit/lexer_unit_test.rb

@@ -4,23 +4,23 @@ class LexerUnitTest < Minitest::Test
   include Liquid
 
   def test_strings
-    tokens = Lexer.new(%! 'this is a test""' "wat 'lol'"!).tokenize
-    assert_equal [[:string,%!'this is a test""'!], [:string, %!"wat 'lol'"!], [:end_of_string]], tokens
+    tokens = Lexer.new(%( 'this is a test""' "wat 'lol'")).tokenize
+    assert_equal [[:string, %('this is a test""')], [:string, %("wat 'lol'")], [:end_of_string]], tokens
   end
 
   def test_integer
     tokens = Lexer.new('hi 50').tokenize
-    assert_equal [[:id,'hi'], [:number, '50'], [:end_of_string]], tokens
+    assert_equal [[:id, 'hi'], [:number, '50'], [:end_of_string]], tokens
   end
 
   def test_float
     tokens = Lexer.new('hi 5.0').tokenize
-    assert_equal [[:id,'hi'], [:number, '5.0'], [:end_of_string]], tokens
+    assert_equal [[:id, 'hi'], [:number, '5.0'], [:end_of_string]], tokens
   end
 
   def test_comparison
     tokens = Lexer.new('== <> contains').tokenize
-    assert_equal [[:comparison,'=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens
+    assert_equal [[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens
   end
 
   def test_specials
@@ -40,7 +40,7 @@ class LexerUnitTest < Minitest::Test
 
   def test_whitespace
     tokens = Lexer.new("five|\n\t ==").tokenize
-    assert_equal [[:id,'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens
+    assert_equal [[:id, 'five'], [:pipe, '|'], [:comparison, '=='], [:end_of_string]], tokens
   end
 
   def test_unexpected_character

test/unit/module_ex_unit_test.rb

@@ -1,87 +0,0 @@
-require 'test_helper'
-
-class TestClassA
-  liquid_methods :allowedA, :chainedB
-  def allowedA
-    'allowedA'
-  end
-  def restrictedA
-    'restrictedA'
-  end
-  def chainedB
-    TestClassB.new
-  end
-end
-
-class TestClassB
-  liquid_methods :allowedB, :chainedC
-  def allowedB
-    'allowedB'
-  end
-  def chainedC
-    TestClassC.new
-  end
-end
-
-class TestClassC
-  liquid_methods :allowedC
-  def allowedC
-    'allowedC'
-  end
-end
-
-class TestClassC::LiquidDropClass
-  def another_allowedC
-    'another_allowedC'
-  end
-end
-
-class ModuleExUnitTest < Minitest::Test
-  include Liquid
-
-  def setup
-    @a = TestClassA.new
-    @b = TestClassB.new
-    @c = TestClassC.new
-  end
-
-  def test_should_create_LiquidDropClass
-    assert TestClassA::LiquidDropClass
-    assert TestClassB::LiquidDropClass
-    assert TestClassC::LiquidDropClass
-  end
-
-  def test_should_respond_to_liquid
-    assert @a.respond_to?(:to_liquid)
-    assert @b.respond_to?(:to_liquid)
-    assert @c.respond_to?(:to_liquid)
-  end
-
-  def test_should_return_LiquidDropClass_object
-    assert @a.to_liquid.is_a?(TestClassA::LiquidDropClass)
-    assert @b.to_liquid.is_a?(TestClassB::LiquidDropClass)
-    assert @c.to_liquid.is_a?(TestClassC::LiquidDropClass)
-  end
-
-  def test_should_respond_to_liquid_methods
-    assert @a.to_liquid.respond_to?(:allowedA)
-    assert @a.to_liquid.respond_to?(:chainedB)
-    assert @b.to_liquid.respond_to?(:allowedB)
-    assert @b.to_liquid.respond_to?(:chainedC)
-    assert @c.to_liquid.respond_to?(:allowedC)
-    assert @c.to_liquid.respond_to?(:another_allowedC)
-  end
-
-  def test_should_not_respond_to_restricted_methods
-    assert ! @a.to_liquid.respond_to?(:restricted)
-  end
-
-  def test_should_use_regular_objects_as_drops
-    assert_template_result 'allowedA', "{{ a.allowedA }}", 'a'=>@a
-    assert_template_result 'allowedB', "{{ a.chainedB.allowedB }}", 'a'=>@a
-    assert_template_result 'allowedC', "{{ a.chainedB.chainedC.allowedC }}", 'a'=>@a
-    assert_template_result 'another_allowedC', "{{ a.chainedB.chainedC.another_allowedC }}", 'a'=>@a
-    assert_template_result '', "{{ a.restricted }}", 'a'=>@a
-    assert_template_result '', "{{ a.unknown }}", 'a'=>@a
-  end
-end # ModuleExTest

test/unit/regexp_unit_test.rb

@@ -18,7 +18,7 @@ class RegexpUnitTest < Minitest::Test
   def test_tags
     assert_equal ['<tr>', '</tr>'], '<tr> </tr>'.scan(QuotedFragment)
     assert_equal ['<tr></tr>'], '<tr></tr>'.scan(QuotedFragment)
-    assert_equal ['<style', 'class="hello">', '</style>'], %|<style class="hello">' </style>|.scan(QuotedFragment)
+    assert_equal ['<style', 'class="hello">', '</style>'], %(<style class="hello">' </style>).scan(QuotedFragment)
   end
 
   def test_double_quoted_words