Switch to aliasing methods

Add new `{% render %}` tag

.github/probots.yml

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

.gitignore

@@ -7,3 +7,4 @@ pkg
 .ruby-version
 Gemfile.lock
 .bundle
+.byebug_history

.rubocop.yml

@@ -1,14 +1,20 @@
-inherit_from: ./.rubocop_todo.yml
+inherit_from:
+  - .rubocop_todo.yml
+  - ./.rubocop_todo.yml
+
+require: rubocop-performance
+
+Performance:
+  Enabled: true
 
 AllCops:
   Exclude:
     - 'performance/shopify/*'
+    - 'vendor/bundle/**/*'
     - 'pkg/**'
 
 Metrics/BlockNesting:
   Max: 3
-  Exclude:
-    - 'lib/liquid/block_body.rb'
 
 Metrics/ModuleLength:
   Enabled: false
@@ -31,8 +37,8 @@ Lint/ParenthesesAsGroupedExpression:
 Lint/UnusedBlockArgument:
   Enabled: false
 
-Lint/EndAlignment:
-  AlignWith: variable
+Layout/EndAlignment:
+  EnforcedStyleAlignWith: variable
 
 Lint/UnusedMethodArgument:
   Enabled: false
@@ -61,10 +67,10 @@ Style/BracesAroundHashParameters:
 Style/NumericLiterals:
   Enabled: false
 
-Style/SpaceInsideBrackets:
+Layout/SpaceInsideArrayLiteralBrackets:
   Enabled: false
 
-Style/SpaceBeforeBlockBraces:
+Layout/SpaceBeforeBlockBraces:
   Enabled: false
 
 Style/Documentation:
@@ -73,19 +79,19 @@ Style/Documentation:
 Style/ClassAndModuleChildren:
   Enabled: false
 
-Style/TrailingComma:
+Style/TrailingCommaInArrayLiteral:
   Enabled: false
 
-Style/IndentHash:
-  EnforcedStyle: consistent
+Style/TrailingCommaInHashLiteral:
+  Enabled: false
 
 Style/FormatString:
   Enabled: false
 
-Style/AlignParameters:
+Layout/AlignParameters:
   EnforcedStyle: with_fixed_indentation
 
-Style/MultilineOperationIndentation:
+Layout/MultilineOperationIndentation:
   EnforcedStyle: indented
 
 Style/IfUnlessModifier:
@@ -94,7 +100,7 @@ Style/IfUnlessModifier:
 Style/RaiseArgs:
   Enabled: false
 
-Style/DeprecatedHashMethods:
+Style/PreferredHashMethods:
   Enabled: false
 
 Style/RegexpLiteral:
@@ -103,13 +109,10 @@ Style/RegexpLiteral:
 Style/SymbolLiteral:
   Enabled: false
 
-Performance/Count:
+Naming/ConstantName:
   Enabled: false
 
-Style/ConstantName:
-  Enabled: false
-
-Style/CaseIndentation:
+Layout/CaseIndentation:
   Enabled: false
 
 Style/ClassVars:
@@ -123,3 +126,7 @@ Style/TrivialAccessors:
 
 Style/WordArray:
   Enabled: false
+
+Naming/MethodName:
+  Exclude:
+    - 'example/server/liquid_servlet.rb'

.rubocop_todo.yml

@@ -1,72 +1,345 @@
-# This configuration was generated by `rubocop --auto-gen-config`
-# on 2015-06-08 18:16:16 +0000 using RuboCop version 0.32.0.
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2019-08-29 00:43:36 +1000 using RuboCop version 0.74.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 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
+# Configuration parameters: TreatCommentsAsGroupSeparators, Include.
+# Include: **/*.gemspec
+Gemspec/OrderedDependencies:
+  Exclude:
+    - 'liquid.gemspec'
 
 # Offense count: 1
-Style/MultilineBlockChain:
-  Enabled: false
+# Configuration parameters: Include.
+# Include: **/*.gemspec, 
+Gemspec/RequiredRubyVersion:
+  Exclude:
+    - 'liquid.gemspec'
 
-# Offense count: 2
-# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
-Style/Next:
+# Offense count: 124
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, IndentationWidth.
+# SupportedStyles: with_first_argument, with_fixed_indentation
+Layout/AlignArguments:
   Enabled: false
 
 # Offense count: 7
 # Cop supports --auto-correct.
-# Configuration parameters: AllowAsExpressionSeparator.
-Style/Semicolon:
+# Configuration parameters: AllowMultipleStyles, EnforcedHashRocketStyle, EnforcedColonStyle, EnforcedLastArgumentHashStyle.
+# SupportedHashRocketStyles: key, separator, table
+# SupportedColonStyles: key, separator, table
+# SupportedLastArgumentHashStyles: always_inspect, always_ignore, ignore_implicit, ignore_explicit
+Layout/AlignHash:
+  Exclude:
+    - 'lib/liquid/condition.rb'
+    - 'lib/liquid/expression.rb'
+    - 'test/unit/context_unit_test.rb'
+
+# Offense count: 6
+# Cop supports --auto-correct.
+Layout/ClosingHeredocIndentation:
+  Exclude:
+    - 'test/integration/tags/for_tag_test.rb'
+
+# Offense count: 27
+# Cop supports --auto-correct.
+Layout/EmptyLineAfterGuardClause:
+  Exclude:
+    - 'lib/liquid/block.rb'
+    - 'lib/liquid/block_body.rb'
+    - 'lib/liquid/context.rb'
+    - 'lib/liquid/drop.rb'
+    - 'lib/liquid/lexer.rb'
+    - 'lib/liquid/parser.rb'
+    - 'lib/liquid/standardfilters.rb'
+    - 'lib/liquid/strainer.rb'
+    - 'lib/liquid/tags/for.rb'
+    - 'lib/liquid/tags/if.rb'
+    - 'lib/liquid/tags/include.rb'
+    - 'lib/liquid/utils.rb'
+    - 'lib/liquid/variable.rb'
+    - 'lib/liquid/variable_lookup.rb'
+
+# Offense count: 5
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: squiggly, active_support, powerpack, unindent
+Layout/IndentHeredoc:
+  Exclude:
+    - 'test/integration/tags/for_tag_test.rb'
+    - 'test/integration/trim_mode_test.rb'
+
+# Offense count: 6
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: symmetrical, new_line, same_line
+Layout/MultilineMethodCallBraceLayout:
+  Exclude:
+    - 'test/integration/error_handling_test.rb'
+    - 'test/unit/strainer_unit_test.rb'
+
+# Offense count: 1
+# Cop supports --auto-correct.
+# Configuration parameters: AllowForAlignment.
+Layout/SpaceAroundOperators:
+  Exclude:
+    - 'lib/liquid/condition.rb'
+
+# Offense count: 2
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: runtime_error, standard_error
+Lint/InheritException:
+  Exclude:
+    - 'lib/liquid/interrupts.rb'
+
+# Offense count: 1
+# Configuration parameters: CheckForMethodsWithNoSideEffects.
+Lint/Void:
+  Exclude:
+    - 'lib/liquid/parse_context.rb'
+
+# Offense count: 53
+Metrics/AbcSize:
+  Max: 56
+
+# Offense count: 12
+Metrics/CyclomaticComplexity:
+  Max: 13
+
+# Offense count: 118
+# Configuration parameters: CountComments, ExcludedMethods.
+Metrics/MethodLength:
+  Max: 38
+
+# Offense count: 9
+Metrics/PerceivedComplexity:
+  Max: 11
+
+# Offense count: 1
+# Cop supports --auto-correct.
+# Configuration parameters: PreferredName.
+Naming/RescuedExceptionsVariableName:
+  Exclude:
+    - 'lib/liquid/context.rb'
+
+# Offense count: 20
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: io, id, to, by, on, in, at, ip, db
+Naming/UncommunicativeMethodParamName:
+  Exclude:
+    - 'example/server/example_servlet.rb'
+    - 'lib/liquid/condition.rb'
+    - 'lib/liquid/context.rb'
+    - 'lib/liquid/standardfilters.rb'
+    - 'lib/liquid/tags/if.rb'
+    - 'lib/liquid/variable.rb'
+    - 'test/integration/filter_test.rb'
+    - 'test/integration/standard_filter_test.rb'
+    - 'test/integration/template_test.rb'
+    - 'test/unit/condition_unit_test.rb'
+
+# Offense count: 5
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: inline, group
+Style/AccessModifierDeclarations:
+  Exclude:
+    - 'lib/liquid/block_body.rb'
+    - 'lib/liquid/tag.rb'
+    - 'lib/liquid/tags/include.rb'
+    - 'test/unit/strainer_unit_test.rb'
+
+# Offense count: 10
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: prefer_alias, prefer_alias_method
+Style/Alias:
+  Exclude:
+    - 'lib/liquid/drop.rb'
+    - 'lib/liquid/i18n.rb'
+    - 'lib/liquid/profiler/hooks.rb'
+    - 'lib/liquid/standardfilters.rb'
+    - 'lib/liquid/tag.rb'
+    - 'lib/liquid/tags/include.rb'
+    - 'lib/liquid/variable.rb'
+
+# Offense count: 22
+Style/CommentedKeyword:
   Enabled: false
 
 # Offense count: 1
 # Cop supports --auto-correct.
-# Configuration parameters: MaxLineLength.
-Style/WhileUntilModifier:
+# Configuration parameters: EnforcedStyle, SingleLineConditionsOnly, IncludeTernaryExpressions.
+# SupportedStyles: assign_to_condition, assign_inside_condition
+Style/ConditionalAssignment:
+  Exclude:
+    - 'lib/liquid/errors.rb'
+
+# Offense count: 1
+# Cop supports --auto-correct.
+Style/EmptyCaseCondition:
+  Exclude:
+    - 'lib/liquid/lexer.rb'
+
+# Offense count: 5
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: compact, expanded
+Style/EmptyMethod:
+  Exclude:
+    - 'lib/liquid/tag.rb'
+    - 'lib/liquid/tags/comment.rb'
+    - 'lib/liquid/tags/include.rb'
+    - 'test/integration/tags/include_tag_test.rb'
+    - 'test/unit/context_unit_test.rb'
+
+# Offense count: 3
+# Cop supports --auto-correct.
+Style/Encoding:
+  Exclude:
+    - 'lib/liquid/version.rb'
+    - 'liquid.gemspec'
+    - 'test/integration/standard_filter_test.rb'
+
+# Offense count: 2
+# Cop supports --auto-correct.
+Style/ExpandPathArguments:
+  Exclude:
+    - 'Rakefile'
+    - 'liquid.gemspec'
+
+# Offense count: 7
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: annotated, template, unannotated
+Style/FormatStringToken:
+  Exclude:
+    - 'test/integration/filter_test.rb'
+    - 'test/integration/hash_ordering_test.rb'
+
+# Offense count: 106
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: always, never
+Style/FrozenStringLiteralComment:
   Enabled: false
+
+# Offense count: 14
+# Configuration parameters: MinBodyLength.
+Style/GuardClause:
+  Exclude:
+    - 'lib/liquid/condition.rb'
+    - 'lib/liquid/lexer.rb'
+    - 'lib/liquid/strainer.rb'
+    - 'lib/liquid/tags/assign.rb'
+    - 'lib/liquid/tags/capture.rb'
+    - 'lib/liquid/tags/case.rb'
+    - 'lib/liquid/tags/for.rb'
+    - 'lib/liquid/tags/include.rb'
+    - 'lib/liquid/tags/raw.rb'
+    - 'lib/liquid/tags/table_row.rb'
+    - 'lib/liquid/variable.rb'
+    - 'test/unit/tokenizer_unit_test.rb'
+
+# Offense count: 53
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: literals, strict
+Style/MutableConstant:
+  Enabled: false
+
+# Offense count: 1
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, MinBodyLength.
+# SupportedStyles: skip_modifier_ifs, always
+Style/Next:
+  Exclude:
+    - 'lib/liquid/tags/for.rb'
+
+# Offense count: 13
+# Cop supports --auto-correct.
+# Configuration parameters: AutoCorrect, EnforcedStyle, IgnoredMethods.
+# SupportedStyles: predicate, comparison
+Style/NumericPredicate:
+  Exclude:
+    - 'spec/**/*'
+    - 'lib/liquid/context.rb'
+    - 'lib/liquid/forloop_drop.rb'
+    - 'lib/liquid/standardfilters.rb'
+    - 'lib/liquid/tablerowloop_drop.rb'
+    - 'test/integration/standard_filter_test.rb'
+    - 'test/integration/template_test.rb'
+
+# Offense count: 14
+# Cop supports --auto-correct.
+# Configuration parameters: PreferredDelimiters.
+Style/PercentLiteralDelimiters:
+  Exclude:
+    - 'lib/liquid/tags/if.rb'
+    - 'liquid.gemspec'
+    - 'test/integration/assign_test.rb'
+    - 'test/integration/standard_filter_test.rb'
+
+# Offense count: 1
+# Cop supports --auto-correct.
+Style/RedundantSelf:
+  Exclude:
+    - 'lib/liquid/strainer.rb'
+
+# Offense count: 3
+# Cop supports --auto-correct.
+# Configuration parameters: ConvertCodeThatCanStartToReturnNil, Whitelist.
+# Whitelist: present?, blank?, presence, try, try!
+Style/SafeNavigation:
+  Exclude:
+    - 'lib/liquid/drop.rb'
+    - 'lib/liquid/strainer.rb'
+    - 'lib/liquid/tokenizer.rb'
+
+# Offense count: 9
+# Cop supports --auto-correct.
+# Configuration parameters: AllowAsExpressionSeparator.
+Style/Semicolon:
+  Exclude:
+    - 'test/integration/error_handling_test.rb'
+    - 'test/integration/template_test.rb'
+    - 'test/unit/context_unit_test.rb'
+
+# Offense count: 7
+# Cop supports --auto-correct.
+# Configuration parameters: MinSize.
+# SupportedStyles: percent, brackets
+Style/SymbolArray:
+  EnforcedStyle: brackets
+
+# Offense count: 2
+# Cop supports --auto-correct.
+# Configuration parameters: EnforcedStyle, AllowSafeAssignment.
+# SupportedStyles: require_parentheses, require_no_parentheses, require_parentheses_when_complex
+Style/TernaryParentheses:
+  Exclude:
+    - 'lib/liquid/context.rb'
+    - 'lib/liquid/utils.rb'
+
+# Offense count: 2
+# Cop supports --auto-correct.
+Style/UnneededPercentQ:
+  Exclude:
+    - 'test/integration/error_handling_test.rb'
+
+# Offense count: 1
+# Cop supports --auto-correct.
+Style/WhileUntilModifier:
+  Exclude:
+    - 'lib/liquid/tags/case.rb'
+
+# Offense count: 665
+# Cop supports --auto-correct.
+# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 294

.travis.yml

@@ -1,25 +1,30 @@
 language: ruby
+cache: bundler
 
 rvm:
-  - 2.1
-  - 2.2
-  - 2.3.3
+  - 2.4
+  - 2.5
+  - &latest_ruby 2.6
+  - 2.7
   - ruby-head
   - jruby-head
-#  - rbx-2
-
-sudo: false
-
-addons:
-  apt:
-    packages:
-    - libgmp3-dev
+  - truffleruby
 
 matrix:
+  include:
+    - rvm: *latest_ruby
+      script: bundle exec rake memory_profile:run
+      name: Profiling Memory Usage
   allow_failures:
+    - rvm: ruby-head
     - rvm: jruby-head
+    - rvm: truffleruby
 
-script: "bundle exec rake"
+branches:
+  only:
+    - master
+    - gh-pages
+    - /.*-stable/
 
 notifications:
   disable: true

Gemfile

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

History.md

@@ -1,5 +1,58 @@
 # Liquid Change Log
 
+## 4.0.3 / 2019-03-12
+
+### Fixed
+* Fix break and continue tags inside included templates in loops (#1072) [Justin Li]
+
+## 4.0.2 / 2019-03-08
+
+### Changed
+* Add `where` filter (#1026) [Samuel Doiron]
+* Add `ParseTreeVisitor` to iterate the Liquid AST (#1025) [Stephen Paul Weber]
+* Improve `strip_html` performance (#1032) [printercu]
+
+### Fixed
+* Add error checking for invalid combinations of inputs to sort, sort_natural, where, uniq, map, compact filters (#1059) [Garland Zhang]
+* Validate the character encoding in url_decode (#1070) [Clayton Smith]
+
+## 4.0.1 / 2018-10-09
+
+### Changed
+* Add benchmark group in Gemfile (#855) [Jerry Liu]
+* Allow benchmarks to benchmark render by itself (#851) [Jerry Liu]
+* Avoid calling `line_number` on String node when rescuing a render error. (#860) [Dylan Thacker-Smith]
+* Avoid duck typing to detect whether to call render on a node. [Dylan Thacker-Smith]
+* Clarify spelling of `reversed` on `for` block tag (#843) [Mark Crossfield]
+* Replace recursion with loop to avoid potential stack overflow from malicious input (#891, #892) [Dylan Thacker-Smith]
+* Limit block tag nesting to 100 (#894) [Dylan Thacker-Smith]
+* Replace `assert_equal nil` with `assert_nil` (#895) [Dylan Thacker-Smith]
+* Remove Spy Gem (#896) [Dylan Thacker-Smith]
+* Add `collection_name` and `variable_name` reader to `For` block (#909)
+* Symbols render as strings (#920) [Justin Li]
+* Remove default value from Hash objects (#932) [Maxime Bedard]
+* Remove one level of nesting (#944) [Dylan Thacker-Smith]
+* Update Rubocop version (#952) [Justin Li]
+* Add `at_least` and `at_most` filters (#954, #958) [Nithin Bekal]
+* Add a regression test for a liquid-c trim mode bug (#972) [Dylan Thacker-Smith]
+* Use https rather than git protocol to fetch liquid-c [Dylan Thacker-Smith]
+* Add tests against Ruby 2.4 (#963) and 2.5 (#981)
+* Replace RegExp literals with constants (#988) [Ashwin Maroli]
+* Replace unnecessary `#each_with_index` with `#each` (#992) [Ashwin Maroli]
+* Improve the unexpected end delimiter message for block tags. (#1003) [Dylan Thacker-Smith]
+* Refactor and optimize rendering (#1005) [Christopher Aue]
+* Add installation instruction (#1006) [Ben Gift]
+* Remove Circle CI (#1010)
+* Rename deprecated `BigDecimal.new` to `BigDecimal` (#1024) [Koichi ITO]
+* Rename deprecated Rubocop name (#1027) [Justin Li]
+
+### Fixed
+* Handle `join` filter on non String joiners (#857) [Richard Monette]
+* Fix duplicate inclusion condition logic error of `Liquid::Strainer.add_filter` method (#861)
+* Fix `escape`, `url_encode`, `url_decode` not handling non-string values (#898) [Thierry Joyal]
+* Fix raise when variable is defined but nil when using `strict_variables` [Pascal Betz]
+* Fix `sort` and `sort_natural` to handle arrays with nils (#930) [Eric Chan]
+
 ## 4.0.0 / 2016-12-14 / branch "4-0-stable"
 
 ### Changed
@@ -20,10 +73,13 @@
 * 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`
+* Remove `liquid_methods` (See https://github.com/Shopify/liquid/pull/568 for replacement)
 * Liquid::Template.register_filter raises when the module overrides registered public methods as private or protected (#705) [Gaurav Chande]
 
 ### Fixed
+
+* Fix variable names being detected as an operator when starting with contains (#788) [Michael Angell]
+* Fix include tag used with strict_variables (#828) [QuickPay]
 * Fix map filter when value is a Proc (#672) [Guillaume Malette]
 * Fix truncate filter when value is not a string (#672) [Guillaume Malette]
 * Fix behaviour of escape filter when input is nil (#665) [Tanel Jakobsoo]

README.md

@@ -42,6 +42,8 @@ Liquid is a template engine which was written with very specific requirements:
 
 ## How to use Liquid
 
+Install Liquid by adding `gem 'liquid'` to your gemfile.
+
 Liquid supports a very simple API based around the Liquid::Template class.
 For standard use you can just pass it the content of a file and call render with a parameters hash.
 

Rakefile

@@ -3,7 +3,7 @@ require 'rake/testtask'
 $LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"
 
-task default: [:rubocop, :test]
+task default: [:test, :rubocop]
 
 desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
@@ -19,8 +19,10 @@ task :warn_test do
 end
 
 task :rubocop do
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new
+  if RUBY_ENGINE == 'ruby'
+    require 'rubocop/rake_task'
+    RuboCop::RakeTask.new
+  end
 end
 
 desc 'runs test suite with both strict and lax parsers'
@@ -32,8 +34,8 @@ task :test do
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
-  if RUBY_ENGINE == 'ruby'
-    ENV['LIQUID-C'] = '1'
+  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
+    ENV['LIQUID_C'] = '1'
 
     ENV['LIQUID_PARSER_MODE'] = 'lax'
     Rake::Task['base_test'].reenable
@@ -85,6 +87,13 @@ namespace :profile do
   end
 end
 
+namespace :memory_profile do
+  desc "Run memory profiler"
+  task :run do
+    ruby "./performance/memory_profile.rb"
+  end
+end
+
 desc "Run example"
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"

circle.yml

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

lib/liquid.rb

@@ -45,6 +45,7 @@ module Liquid
 end
 
 require "liquid/version"
+require 'liquid/parse_tree_visitor'
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
@@ -73,7 +74,13 @@ require 'liquid/condition'
 require 'liquid/utils'
 require 'liquid/tokenizer'
 require 'liquid/parse_context'
+require 'liquid/partial_cache'
+require 'liquid/usage'
 
 # Load all the tags of the standard library
 #
 Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
+
+# Load all usage tracking
+#
+Dir["#{__dir__}/liquid/usages/*.rb"].each { |f| require f }

lib/liquid/block.rb

@@ -1,5 +1,7 @@
 module Liquid
   class Block < Tag
+    MAX_DEPTH = 100
+
     def initialize(tag_name, markup, options)
       super
       @blank = true
@@ -11,6 +13,7 @@ module Liquid
       end
     end
 
+    # For backwards compatibility
     def render(context)
       @body.render(context)
     end
@@ -24,12 +27,12 @@ module Liquid
     end
 
     def unknown_tag(tag, _params, _tokens)
-      case tag
-      when 'else'.freeze
+      if tag == 'else'.freeze
         raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze,
           block_name: block_name))
-      when 'end'.freeze
+      elsif tag.start_with?('end'.freeze)
         raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
+          tag: tag,
           block_name: block_name,
           block_delimiter: block_delimiter))
       else
@@ -48,17 +51,25 @@ module Liquid
     protected
 
     def parse_body(body, tokens)
-      body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
-        @blank &&= body.blank?
+      if parse_context.depth >= MAX_DEPTH
+        raise StackLevelError, "Nesting too deep".freeze
+      end
+      parse_context.depth += 1
+      begin
+        body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
+          @blank &&= body.blank?
 
-        return false if end_tag_name == block_delimiter
-        unless end_tag_name
-          raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
+          return false if end_tag_name == block_delimiter
+          unless end_tag_name
+            raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
+          end
+
+          # this tag is not registered with the system
+          # pass it to the current block for special handling or error reporting
+          unknown_tag(end_tag_name, end_tag_params, tokens)
         end
-
-        # this tag is not registered with the system
-        # pass it to the current block for special handling or error reporting
-        unknown_tag(end_tag_name, end_tag_params, tokens)
+      ensure
+        parse_context.depth -= 1
       end
 
       true

lib/liquid/block_body.rb

@@ -1,7 +1,9 @@
 module Liquid
   class BlockBody
-    FullToken = /\A#{TagStart}#{WhitespaceControl}?\s*(\w+)\s*(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    LiquidTagToken = /\A\s*(\w+)\s*(.*?)\z/o
+    FullToken = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
     ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    WhitespaceOrNothing = /\A\s*\z/
     TAGSTART = "{%".freeze
     VARSTART = "{{".freeze
 
@@ -12,41 +14,83 @@ module Liquid
       @blank = true
     end
 
-    def parse(tokenizer, parse_context)
+    def parse(tokenizer, parse_context, &block)
       parse_context.line_number = tokenizer.line_number
+
+      if tokenizer.for_liquid_tag
+        parse_for_liquid_tag(tokenizer, parse_context, &block)
+      else
+        parse_for_document(tokenizer, parse_context, &block)
+      end
+    end
+
+    private def parse_for_liquid_tag(tokenizer, parse_context)
       while token = tokenizer.shift
-        unless token.empty?
-          case
-          when token.start_with?(TAGSTART)
-            whitespace_handler(token, parse_context)
-            if token =~ FullToken
-              tag_name = $1
-              markup = $2
-              # fetch the tag from registered blocks
-              if tag = registered_tags[tag_name]
-                new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
-                @blank &&= new_tag.blank?
-                @nodelist << new_tag
-              else
-                # end parsing if we reach an unknown tag and let the caller decide
-                # determine how to proceed
-                return yield tag_name, markup
-              end
-            else
-              raise_missing_tag_terminator(token, parse_context)
-            end
-          when token.start_with?(VARSTART)
-            whitespace_handler(token, parse_context)
-            @nodelist << create_variable(token, parse_context)
-            @blank = false
-          else
-            if parse_context.trim_whitespace
-              token.lstrip!
-            end
-            parse_context.trim_whitespace = false
-            @nodelist << token
-            @blank &&= !!(token =~ /\A\s*\z/)
+        unless token.empty? || token =~ WhitespaceOrNothing
+          unless token =~ LiquidTagToken
+            # line isn't empty but didn't match tag syntax, yield and let the
+            # caller raise a syntax error
+            return yield token, token
           end
+          tag_name = $1
+          markup = $2
+          unless tag = registered_tags[tag_name]
+            # end parsing if we reach an unknown tag and let the caller decide
+            # determine how to proceed
+            return yield tag_name, markup
+          end
+          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
+          @blank &&= new_tag.blank?
+          @nodelist << new_tag
+        end
+        parse_context.line_number = tokenizer.line_number
+      end
+
+      yield nil, nil
+    end
+
+    private def parse_for_document(tokenizer, parse_context, &block)
+      while token = tokenizer.shift
+        next if token.empty?
+        case
+        when token.start_with?(TAGSTART)
+          whitespace_handler(token, parse_context)
+          unless token =~ FullToken
+            raise_missing_tag_terminator(token, parse_context)
+          end
+          tag_name = $2
+          markup = $4
+
+          if parse_context.line_number
+            # newlines inside the tag should increase the line number,
+            # particularly important for multiline {% liquid %} tags
+            parse_context.line_number += $1.count("\n".freeze) + $3.count("\n".freeze)
+          end
+
+          if tag_name == 'liquid'.freeze
+            liquid_tag_tokenizer = Tokenizer.new(markup, line_number: parse_context.line_number, for_liquid_tag: true)
+            next parse_for_liquid_tag(liquid_tag_tokenizer, parse_context, &block)
+          end
+
+          unless tag = registered_tags[tag_name]
+            # end parsing if we reach an unknown tag and let the caller decide
+            # determine how to proceed
+            return yield tag_name, markup
+          end
+          new_tag = tag.parse(tag_name, markup, tokenizer, parse_context)
+          @blank &&= new_tag.blank?
+          @nodelist << new_tag
+        when token.start_with?(VARSTART)
+          whitespace_handler(token, parse_context)
+          @nodelist << create_variable(token, parse_context)
+          @blank = false
+        else
+          if parse_context.trim_whitespace
+            token.lstrip!
+          end
+          parse_context.trim_whitespace = false
+          @nodelist << token
+          @blank &&= !!(token =~ WhitespaceOrNothing)
         end
         parse_context.line_number = tokenizer.line_number
       end
@@ -69,51 +113,57 @@ module Liquid
     end
 
     def render(context)
-      output = []
+      render_to_output_buffer(context, '')
+    end
+
+    def render_to_output_buffer(context, output)
       context.resource_limits.render_score += @nodelist.length
 
-      @nodelist.each do |token|
-        # Break out if we have any unhanded interrupts.
-        break if context.interrupt?
+      idx = 0
+      while node = @nodelist[idx]
+        previous_output_size = output.bytesize
 
-        begin
+        case node
+        when String
+          output << node
+        when Variable
+          render_node(context, output, node)
+        when Block
+          render_node(context, node.blank? ? '' : output, node)
+          break if context.interrupt? # might have happened in a for-block
+        when Continue, Break
           # If we get an Interrupt that means the block must stop processing. An
           # Interrupt is any command that stops block execution such as {% break %}
           # or {% continue %}
-          if token.is_a?(Continue) || token.is_a?(Break)
-            context.push_interrupt(token.interrupt)
-            break
-          end
-
-          node_output = render_node(token, context)
-
-          unless token.is_a?(Block) && token.blank?
-            output << node_output
-          end
-        rescue MemoryError => e
-          raise e
-        rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
-          context.handle_error(e, token.line_number, token.raw)
-          output << nil
-        rescue ::StandardError => e
-          output << context.handle_error(e, token.line_number, token.raw)
+          context.push_interrupt(node.interrupt)
+          break
+        else # Other non-Block tags
+          render_node(context, output, node)
+          break if context.interrupt? # might have happened through an include
         end
+        idx += 1
+
+        raise_if_resource_limits_reached(context, output.bytesize - previous_output_size)
       end
 
-      output.join
+      output
     end
 
     private
 
-    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
+    def render_node(context, output, node)
+      node.render_to_output_buffer(context, output)
+    rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
+      context.handle_error(e, node.line_number)
+    rescue ::StandardError => e
+      line_number = node.is_a?(String) ? nil : node.line_number
+      output << context.handle_error(e, line_number)
+    end
 
-      context.resource_limits.render_length += node_output.length
-      if context.resource_limits.reached?
-        raise MemoryError.new("Memory limits exceeded".freeze)
-      end
-      node_output
+    def raise_if_resource_limits_reached(context, length)
+      context.resource_limits.render_length += length
+      return unless context.resource_limits.reached?
+      raise MemoryError.new("Memory limits exceeded".freeze)
     end
 
     def create_variable(token, parse_context)

lib/liquid/condition.rb

@@ -29,7 +29,7 @@ module Liquid
       @@operators
     end
 
-    attr_reader :attachment
+    attr_reader :attachment, :child_condition
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
@@ -41,16 +41,22 @@ module Liquid
     end
 
     def evaluate(context = Context.new)
-      result = interpret_condition(left, right, operator, context)
+      condition = self
+      result = nil
+      loop do
+        result = interpret_condition(condition.left, condition.right, condition.operator, context)
 
-      case @child_relation
-      when :or
-        result || @child_condition.evaluate(context)
-      when :and
-        result && @child_condition.evaluate(context)
-      else
-        result
+        case condition.child_relation
+        when :or
+          break if result
+        when :and
+          break unless result
+        else
+          break
+        end
+        condition = condition.child_condition
       end
+      result
     end
 
     def or(condition)
@@ -75,6 +81,10 @@ module Liquid
       "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
     end
 
+    protected
+
+    attr_reader :child_relation
+
     private
 
     def equal_variables(left, right)
@@ -110,7 +120,7 @@ module Liquid
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
-      elsif left.respond_to?(operation) && right.respond_to?(operation)
+      elsif left.respond_to?(operation) && right.respond_to?(operation) && !left.is_a?(Hash) && !right.is_a?(Hash)
         begin
           left.send(operation, right)
         rescue ::ArgumentError => e
@@ -118,6 +128,15 @@ module Liquid
         end
       end
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.left, @node.right,
+          @node.child_condition, @node.attachment
+        ].compact
+      end
+    end
   end
 
   class ElseCondition < Condition

lib/liquid/context.rb

@@ -12,17 +12,25 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
     attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-      @environments     = [environments].flatten
-      @scopes           = [(outer_scope || {})]
-      @registers        = registers
-      @errors           = []
-      @partial          = false
-      @strict_variables = false
-      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+    # rubocop:disable Metrics/ParameterLists
+    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_registers: {}, static_environments: {})
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_registers, static_environments)
+    end
+
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_registers = {}, static_environments = {})
+      @environments        = [environments].flatten
+      @static_environments = [static_environments].flatten.map(&:freeze).freeze
+      @scopes              = [(outer_scope || {})]
+      @registers           = registers
+      @static_registers    = static_registers.freeze
+      @errors              = []
+      @partial             = false
+      @strict_variables    = false
+      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      @base_scope_depth    = 0
       squash_instance_assigns_with_environments
 
       @this_stack_used = false
@@ -36,6 +44,7 @@ module Liquid
       @filters = []
       @global_filter = nil
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def warnings
       @warnings ||= []
@@ -74,7 +83,7 @@ module Liquid
       @interrupts.pop
     end
 
-    def handle_error(e, line_number = nil, raw_token = nil)
+    def handle_error(e, line_number = nil)
       e = internal_error unless e.is_a?(Liquid::Error)
       e.template_name ||= template_name
       e.line_number ||= line_number
@@ -89,7 +98,7 @@ module Liquid
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope = {})
       @scopes.unshift(new_scope)
-      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > 100
+      check_overflow
     end
 
     # Merge a hash of variables in the current local scope
@@ -126,6 +135,25 @@ module Liquid
       @this_stack_used = old_stack_used
     end
 
+    # Creates a new context inheriting resource limits, filters, environment etc.,
+    # but with an isolated scope.
+    def new_isolated_subcontext
+      check_overflow
+
+      Context.build(
+        resource_limits: resource_limits,
+        static_environments: static_environments,
+        static_registers: static_registers
+      ).tap do |subcontext|
+        subcontext.base_scope_depth = base_scope_depth + 1
+        subcontext.exception_renderer = exception_renderer
+        subcontext.filters = @filters
+        subcontext.strainer = nil
+        subcontext.errors = errors
+        subcontext.warnings = warnings
+      end
+    end
+
     def clear_instance_assigns
       @scopes[0] = {}
     end
@@ -160,35 +188,25 @@ module Liquid
     end
 
     # Fetches an object starting at the local scope and then moving up the hierachy
-    def find_variable(key)
+    def find_variable(key, raise_on_not_found: true)
       # This was changed from find() to find_index() because this is a very hot
       # path and find_index() is optimized in MRI to reduce object allocation
       index = @scopes.find_index { |s| s.key?(key) }
-      scope = @scopes[index] if index
 
-      variable = nil
-
-      if scope.nil?
-        @environments.each do |e|
-          variable = lookup_and_evaluate(e, key)
-          unless variable.nil?
-            scope = e
-            break
-          end
-        end
+      variable = if index
+        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
+      else
+        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
       end
 
-      scope ||= @environments.last || @scopes.last
-      variable ||= lookup_and_evaluate(scope, key)
-
       variable = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
       variable
     end
 
-    def lookup_and_evaluate(obj, key)
-      if @strict_variables && obj.respond_to?(:key?) && !obj.key?(key)
+    def lookup_and_evaluate(obj, key, raise_on_not_found: true)
+      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
         raise Liquid::UndefinedVariable, "undefined variable #{key}"
       end
 
@@ -201,8 +219,38 @@ module Liquid
       end
     end
 
+    protected
+
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
+
     private
 
+    attr_reader :base_scope_depth
+
+    def try_variable_find_in_environments(key, raise_on_not_found:)
+      @environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+      end
+      @static_environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+      end
+      nil
+    end
+
+    def check_overflow
+      raise StackLevelError, "Nesting too deep".freeze if overflow?
+    end
+
+    def overflow?
+      base_scope_depth + @scopes.length > Block::MAX_DEPTH
+    end
+
     def internal_error
       # raise and catch to set backtrace and cause on exception
       raise Liquid::InternalError, 'internal'

lib/liquid/expression.rb

@@ -19,22 +19,26 @@ module Liquid
       'false'.freeze => false,
       'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
       'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
-    }
+    }.freeze
+
+    SINGLE_QUOTED_STRING = /\A'(.*)'\z/m
+    DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m
+    INTEGERS_REGEX       = /\A(-?\d+)\z/
+    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/
+    RANGES_REGEX         = /\A\((\S+)\.\.(\S+)\)\z/
 
     def self.parse(markup)
       if LITERALS.key?(markup)
         LITERALS[markup]
       else
         case markup
-        when /\A'(.*)'\z/m # Single quoted strings
+        when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
           $1
-        when /\A"(.*)"\z/m # Double quoted strings
-          $1
-        when /\A(-?\d+)\z/ # Integer and floats
+        when INTEGERS_REGEX
           $1.to_i
-        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
+        when RANGES_REGEX
           RangeLookup.parse($1, $2)
-        when /\A(-?\d[\d\.]+)\z/ # Floats
+        when FLOATS_REGEX
           $1.to_f
         else
           VariableLookup.parse(markup)

lib/liquid/extensions.rb

@@ -7,6 +7,12 @@ class String # :nodoc:
   end
 end
 
+class Symbol # :nodoc:
+  def to_liquid
+    to_s
+  end
+end
+
 class Array # :nodoc:
   def to_liquid
     self

lib/liquid/i18n.rb

@@ -26,7 +26,7 @@ module Liquid
     def interpolate(name, vars)
       name.gsub(/%\{(\w+)\}/) do
         # raise TranslationError, "Undefined key #{$1} for interpolation in translation #{name}"  unless vars[$1.to_sym]
-        "#{vars[$1.to_sym]}"
+        (vars[$1.to_sym]).to_s
       end
     end
 

lib/liquid/lexer.rb

@@ -12,23 +12,25 @@ module Liquid
       ')'.freeze => :close_round,
       '?'.freeze => :question,
       '-'.freeze => :dash
-    }
+    }.freeze
     IDENTIFIER = /[a-zA-Z_][\w-]*\??/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
     NUMBER_LITERAL = /-?\d+(\.\d+)?/
     DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains/
+    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    WHITESPACE_OR_NOTHING = /\s*/
 
     def initialize(input)
-      @ss = StringScanner.new(input.rstrip)
+      @ss = StringScanner.new(input)
     end
 
     def tokenize
       @output = []
 
       until @ss.eos?
-        @ss.skip(/\s*/)
+        @ss.skip(WHITESPACE_OR_NOTHING)
+        break if @ss.eos?
         tok = case
         when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
         when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]

lib/liquid/locales/en.yml

@@ -14,7 +14,7 @@
       if: "Syntax Error in tag 'if' - Valid syntax: if [expression]"
       include: "Error in tag 'include' - Valid syntax: include '[template]' (with|for) [object|collection]"
       unknown_tag: "Unknown tag '%{tag}'"
-      invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      invalid_delimiter: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
       unexpected_else: "%{block_name} tag does not expect 'else' tag"
       unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
       tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
@@ -22,5 +22,6 @@
       tag_never_closed: "'%{block_name}' tag was never closed"
       meta_syntax_error: "Liquid syntax error: #{e.message}"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
+      render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"

lib/liquid/parse_context.rb

@@ -1,12 +1,13 @@
 module Liquid
   class ParseContext
-    attr_accessor :locale, :line_number, :trim_whitespace
+    attr_accessor :locale, :line_number, :trim_whitespace, :depth
     attr_reader :partial, :warnings, :error_mode
 
     def initialize(options = {})
       @template_options = options ? options.dup : {}
       @locale = @template_options[:locale] ||= I18n.new
       @warnings = []
+      self.depth = 0
       self.partial = false
     end
 

lib/liquid/parse_tree_visitor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Liquid
+  class ParseTreeVisitor
+    def self.for(node, callbacks = Hash.new(proc {}))
+      if defined?(node.class::ParseTreeVisitor)
+        node.class::ParseTreeVisitor
+      else
+        self
+      end.new(node, callbacks)
+    end
+
+    def initialize(node, callbacks)
+      @node = node
+      @callbacks = callbacks
+    end
+
+    def add_callback_for(*classes, &block)
+      callback = block
+      callback = ->(node, _) { yield node } if block.arity.abs == 1
+      callback = ->(_, _) { yield } if block.arity.zero?
+      classes.each { |klass| @callbacks[klass] = callback }
+      self
+    end
+
+    def visit(context = nil)
+      children.map do |node|
+        item, new_context = @callbacks[node.class].call(node, context)
+        [
+          item,
+          ParseTreeVisitor.for(node, @callbacks).visit(new_context || context)
+        ]
+      end
+    end
+
+    protected
+
+    def children
+      @node.respond_to?(:nodelist) ? Array(@node.nodelist) : []
+    end
+  end
+end

lib/liquid/parser.rb

@@ -44,11 +44,14 @@ module Liquid
       tok[0] == type
     end
 
+    SINGLE_TOKEN_EXPRESSION_TYPES = [:string, :number].freeze
+    private_constant :SINGLE_TOKEN_EXPRESSION_TYPES
+
     def expression
       token = @tokens[@p]
       if token[0] == :id
         variable_signature
-      elsif [:string, :number].include? token[0]
+      elsif SINGLE_TOKEN_EXPRESSION_TYPES.include? token[0]
         consume
       elsif token.first == :open_round
         consume

lib/liquid/partial_cache.rb

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

lib/liquid/profiler/hooks.rb

@@ -1,8 +1,8 @@
 module Liquid
   class BlockBody
-    def render_node_with_profiling(node, context)
+    def render_node_with_profiling(context, output, node)
       Profiler.profile_node_render(node) do
-        render_node_without_profiling(node, context)
+        render_node_without_profiling(context, output, node)
       end
     end
 
@@ -11,13 +11,13 @@ module Liquid
   end
 
   class Include < Tag
-    def render_with_profiling(context)
+    def render_to_output_buffer_with_profiling(context, output)
       Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_without_profiling(context)
+        render_to_output_buffer_without_profiling(context, output)
       end
     end
 
-    alias_method :render_without_profiling, :render
-    alias_method :render, :render_with_profiling
+    alias_method :render_to_output_buffer_without_profiling, :render_to_output_buffer
+    alias_method :render_to_output_buffer, :render_to_output_buffer_with_profiling
   end
 end

lib/liquid/standardfilters.rb

@@ -9,8 +9,14 @@ module Liquid
       '<'.freeze => '&lt;'.freeze,
       '"'.freeze => '&quot;'.freeze,
       "'".freeze => '&#39;'.freeze
-    }
+    }.freeze
     HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
+    STRIP_HTML_BLOCKS = Regexp.union(
+      /<script.*?<\/script>/m,
+      /<!--.*?-->/m,
+      /<style.*?<\/style>/m
+    )
+    STRIP_HTML_TAGS = /<.*?>/m
 
     # Return the size of an array or of an string
     def size(input)
@@ -33,7 +39,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input).untaint unless input.nil?
+      CGI.escapeHTML(input.to_s).untaint unless input.nil?
     end
     alias_method :h, :escape
 
@@ -42,11 +48,16 @@ module Liquid
     end
 
     def url_encode(input)
-      CGI.escape(input) unless input.nil?
+      CGI.escape(input.to_s) unless input.nil?
     end
 
     def url_decode(input)
-      CGI.unescape(input) unless input.nil?
+      return if input.nil?
+
+      result = CGI.unescape(input.to_s)
+      raise Liquid::ArgumentError, "invalid byte sequence in #{result.encoding}" unless result.valid_encoding?
+
+      result
     end
 
     def slice(input, offset, length = nil)
@@ -68,7 +79,7 @@ module Liquid
       truncate_string_str = truncate_string.to_s
       l = length - truncate_string_str.length
       l = 0 if l < 0
-      input_str.length > length ? input_str[0...l] + truncate_string_str : input_str
+      input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
     end
 
     def truncatewords(input, words = 15, truncate_string = "...".freeze)
@@ -77,7 +88,7 @@ module Liquid
       words = Utils.to_integer(words)
       l = words - 1
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string.to_s : input
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze).concat(truncate_string.to_s) : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -103,7 +114,9 @@ module Liquid
 
     def strip_html(input)
       empty = ''.freeze
-      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
+      result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
+      result.gsub!(STRIP_HTML_TAGS, empty)
+      result
     end
 
     # Remove all newlines from the string
@@ -120,19 +133,18 @@ module Liquid
     # provide optional property with which to sort an array of hashes or drops
     def sort(input, property = nil)
       ary = InputIterator.new(input)
+
+      return [] if ary.empty?
+
       if property.nil?
-        ary.sort
-      elsif ary.empty? # The next two cases assume a non-empty array.
-        []
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
         ary.sort do |a, b|
-          a = a[property]
-          b = b[property]
-          if a && b
-            a <=> b
-          else
-            a ? -1 : 1
-          end
+          nil_safe_compare(a, b)
+        end
+      elsif ary.all? { |el| el.respond_to?(:[]) }
+        begin
+          ary.sort { |a, b| nil_safe_compare(a[property], b[property]) }
+        rescue TypeError
+          raise_property_error(property)
         end
       end
     end
@@ -142,12 +154,40 @@ module Liquid
     def sort_natural(input, property = nil)
       ary = InputIterator.new(input)
 
+      return [] if ary.empty?
+
       if property.nil?
-        ary.sort { |a, b| a.casecmp(b) }
-      elsif ary.empty? # The next two cases assume a non-empty array.
+        ary.sort do |a, b|
+          nil_safe_casecmp(a, b)
+        end
+      elsif ary.all? { |el| el.respond_to?(:[]) }
+        begin
+          ary.sort { |a, b| nil_safe_casecmp(a[property], b[property]) }
+        rescue TypeError
+          raise_property_error(property)
+        end
+      end
+    end
+
+    # Filter the elements of an array to those with a certain property value.
+    # By default the target is any truthy value.
+    def where(input, property, target_value = nil)
+      ary = InputIterator.new(input)
+
+      if ary.empty?
         []
-      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        ary.sort { |a, b| a[property].casecmp(b[property]) }
+      elsif ary.first.respond_to?(:[]) && target_value.nil?
+        begin
+          ary.select { |item| item[property] }
+        rescue TypeError
+          raise_property_error(property)
+        end
+      elsif ary.first.respond_to?(:[])
+        begin
+          ary.select { |item| item[property] == target_value }
+        rescue TypeError
+          raise_property_error(property)
+        end
       end
     end
 
@@ -161,7 +201,11 @@ module Liquid
       elsif ary.empty? # The next two cases assume a non-empty array.
         []
       elsif ary.first.respond_to?(:[])
-        ary.uniq{ |a| a[property] }
+        begin
+          ary.uniq { |a| a[property] }
+        rescue TypeError
+          raise_property_error(property)
+        end
       end
     end
 
@@ -183,6 +227,8 @@ module Liquid
           r.is_a?(Proc) ? r.call : r
         end
       end
+    rescue TypeError
+      raise_property_error(property)
     end
 
     # Remove nils within an array
@@ -195,7 +241,11 @@ module Liquid
       elsif ary.empty? # The next two cases assume a non-empty array.
         []
       elsif ary.first.respond_to?(:[])
-        ary.reject{ |a| a[property].nil? }
+        begin
+          ary.reject { |a| a[property].nil? }
+        rescue TypeError
+          raise_property_error(property)
+        end
       end
     end
 
@@ -353,6 +403,22 @@ module Liquid
       raise Liquid::FloatDomainError, e.message
     end
 
+    def at_least(input, n)
+      min_value = Utils.to_number(n)
+
+      result = Utils.to_number(input)
+      result = min_value if min_value > result
+      result.is_a?(BigDecimal) ? result.to_f : result
+    end
+
+    def at_most(input, n)
+      max_value = Utils.to_number(n)
+
+      result = Utils.to_number(input)
+      result = max_value if max_value < result
+      result.is_a?(BigDecimal) ? result.to_f : result
+    end
+
     def default(input, default_value = ''.freeze)
       if !input || input.respond_to?(:empty?) && input.empty?
         default_value
@@ -363,11 +429,31 @@ module Liquid
 
     private
 
+    def raise_property_error(property)
+      raise Liquid::ArgumentError.new("cannot select the property '#{property}'")
+    end
+
     def apply_operation(input, operand, operation)
       result = Utils.to_number(input).send(operation, Utils.to_number(operand))
       result.is_a?(BigDecimal) ? result.to_f : result
     end
 
+    def nil_safe_compare(a, b)
+      if !a.nil? && !b.nil?
+        a <=> b
+      else
+        a.nil? ? 1 : -1
+      end
+    end
+
+    def nil_safe_casecmp(a, b)
+      if !a.nil? && !b.nil?
+        a.to_s.casecmp(b.to_s)
+      else
+        a.nil? ? 1 : -1
+      end
+    end
+
     class InputIterator
       include Enumerable
 
@@ -384,7 +470,7 @@ module Liquid
       end
 
       def join(glue)
-        to_a.join(glue)
+        to_a.join(glue.to_s)
       end
 
       def concat(args)

lib/liquid/strainer.rb

@@ -27,7 +27,7 @@ module Liquid
 
     def self.add_filter(filter)
       raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-      unless self.class.include?(filter)
+      unless self.include?(filter)
         invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
         if invokable_non_public_methods.any?
           raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"

lib/liquid/tag.rb

@@ -5,8 +5,8 @@ module Liquid
     include ParserSwitching
 
     class << self
-      def parse(tag_name, markup, tokenizer, options)
-        tag = new(tag_name, markup, options)
+      def parse(tag_name, markup, tokenizer, parse_context)
+        tag = new(tag_name, markup, parse_context)
         tag.parse(tokenizer)
         tag
       end
@@ -36,6 +36,14 @@ module Liquid
       ''.freeze
     end
 
+    # For backwards compatibility with custom tags. In a future release, the semantics
+    # of the `render_to_output_buffer` method will become the default and the `render`
+    # method will be removed.
+    def render_to_output_buffer(context, output)
+      output << render(context)
+      output
+    end
+
     def blank?
       false
     end

lib/liquid/tags/assign.rb

@@ -10,21 +10,27 @@ module Liquid
   class Assign < Tag
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
+    def self.syntax_error_translation_key
+      "errors.syntax.assign".freeze
+    end
+
+    attr_reader :to, :from
+
     def initialize(tag_name, markup, options)
       super
       if markup =~ Syntax
         @to = $1
         @from = Variable.new($2, options)
       else
-        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
+        raise SyntaxError.new(options[:locale].t(self.class.syntax_error_translation_key))
       end
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       val = @from.render(context)
       context.scopes.last[@to] = val
       context.resource_limits.assign_score += assign_score_of(val)
-      ''.freeze
+      output
     end
 
     def blank?
@@ -35,7 +41,7 @@ module Liquid
 
     def assign_score_of(val)
       if val.instance_of?(String)
-        val.length
+        val.bytesize
       elsif val.instance_of?(Array) || val.instance_of?(Hash)
         sum = 1
         # Uses #each to avoid extra allocations.
@@ -45,6 +51,12 @@ module Liquid
         1
       end
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.from]
+      end
+    end
   end
 
   Template.register_tag('assign'.freeze, Assign)

lib/liquid/tags/capture.rb

@@ -22,11 +22,12 @@ module Liquid
       end
     end
 
-    def render(context)
-      output = super
+    def render_to_output_buffer(context, output)
+      previous_output_size = output.bytesize
+      super
       context.scopes.last[@to] = output
-      context.resource_limits.assign_score += output.length
-      ''.freeze
+      context.resource_limits.assign_score += (output.bytesize - previous_output_size)
+      output
     end
 
     def blank?

lib/liquid/tags/case.rb

@@ -3,6 +3,8 @@ module Liquid
     Syntax     = /(#{QuotedFragment})/o
     WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
 
+    attr_reader :blocks, :left
+
     def initialize(tag_name, markup, options)
       super
       @blocks = []
@@ -36,21 +38,21 @@ module Liquid
       end
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       context.stack do
         execute_else_block = true
 
-        output = ''
         @blocks.each do |block|
           if block.else?
-            return block.attachment.render(context) if execute_else_block
+            block.attachment.render_to_output_buffer(context, output) if execute_else_block
           elsif block.evaluate(context)
             execute_else_block = false
-            output << block.attachment.render(context)
+            block.attachment.render_to_output_buffer(context, output)
           end
         end
-        output
       end
+
+      output
     end
 
     private
@@ -80,6 +82,12 @@ module Liquid
       block.attach(BlockBody.new)
       @blocks << block
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.left] + @node.blocks
+      end
+    end
   end
 
   Template.register_tag('case'.freeze, Case)

lib/liquid/tags/comment.rb

@@ -1,7 +1,7 @@
 module Liquid
   class Comment < Block
-    def render(_context)
-      ''.freeze
+    def render_to_output_buffer(_context, output)
+      output
     end
 
     def unknown_tag(_tag, _markup, _tokens)

lib/liquid/tags/cycle.rb

@@ -15,6 +15,8 @@ module Liquid
     SimpleSyntax = /\A#{QuotedFragment}+/o
     NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
 
+    attr_reader :variables
+
     def initialize(tag_name, markup, options)
       super
       case markup
@@ -29,18 +31,29 @@ module Liquid
       end
     end
 
-    def render(context)
-      context.registers[:cycle] ||= Hash.new(0)
+    def render_to_output_buffer(context, output)
+      context.registers[:cycle] ||= {}
 
       context.stack do
         key = context.evaluate(@name)
-        iteration = context.registers[:cycle][key]
-        result = context.evaluate(@variables[iteration])
+        iteration = context.registers[:cycle][key].to_i
+
+        val = context.evaluate(@variables[iteration])
+
+        if val.is_a?(Array)
+          val = val.join
+        elsif !val.is_a?(String)
+          val = val.to_s
+        end
+
+        output << val
+
         iteration += 1
         iteration  = 0 if iteration >= @variables.size
         context.registers[:cycle][key] = iteration
-        result
       end
+
+      output
     end
 
     private
@@ -51,6 +64,12 @@ module Liquid
         $1 ? Expression.parse($1) : nil
       end.compact
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        Array(@node.variables)
+      end
+    end
   end
 
   Template.register_tag('cycle', Cycle)

lib/liquid/tags/decrement.rb

@@ -23,11 +23,12 @@ module Liquid
       @variable = markup.strip
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       value = context.environments.first[@variable] ||= 0
       value -= 1
       context.environments.first[@variable] = value
-      value.to_s
+      output << value.to_s
+      output
     end
   end
 

lib/liquid/tags/echo.rb

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

lib/liquid/tags/for.rb

@@ -23,7 +23,7 @@ module Liquid
   #      {{ item.name }}
   #    {% end %}
   #
-  #  To reverse the for loop simply use {% for item in collection reversed %}
+  #  To reverse the for loop simply use {% for item in collection reversed %} (note that the flag's spelling is different to the filter `reverse`)
   #
   # == Available variables:
   #
@@ -46,6 +46,8 @@ module Liquid
   class For < Block
     Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
 
+    attr_reader :collection_name, :variable_name, :limit, :from
+
     def initialize(tag_name, markup, options)
       super
       @from = @limit = nil
@@ -68,14 +70,16 @@ module Liquid
       @else_block = BlockBody.new
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       segment = collection_segment(context)
 
       if segment.empty?
-        render_else(context)
+        render_else(context, output)
       else
-        render_segment(context, segment)
+        render_segment(context, output, segment)
       end
+
+      output
     end
 
     protected
@@ -117,19 +121,28 @@ module Liquid
     private
 
     def collection_segment(context)
-      offsets = context.registers[:for] ||= Hash.new(0)
+      offsets = context.registers[:for] ||= {}
 
       from = if @from == :continue
         offsets[@name].to_i
       else
-        context.evaluate(@from).to_i
+        from_value = context.evaluate(@from)
+        if from_value.nil?
+          0
+        else
+          Utils.to_integer(from_value)
+        end
       end
 
       collection = context.evaluate(@collection_name)
       collection = collection.to_a if collection.is_a?(Range)
 
-      limit = context.evaluate(@limit)
-      to = limit ? limit.to_i + from : nil
+      limit_value = context.evaluate(@limit)
+      to = if limit_value.nil?
+        nil
+      else
+        Utils.to_integer(limit_value) + from
+      end
 
       segment = Utils.slice_collection(collection, from, to)
       segment.reverse! if @reversed
@@ -139,12 +152,10 @@ module Liquid
       segment
     end
 
-    def render_segment(context, segment)
+    def render_segment(context, output, segment)
       for_stack = context.registers[:for_stack] ||= []
       length = segment.length
 
-      result = ''
-
       context.stack do
         loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
 
@@ -153,9 +164,9 @@ module Liquid
         begin
           context['forloop'.freeze] = loop_vars
 
-          segment.each_with_index do |item, index|
+          segment.each do |item|
             context[@variable_name] = item
-            result << @for_block.render(context)
+            @for_block.render_to_output_buffer(context, output)
             loop_vars.send(:increment!)
 
             # Handle any interrupts if they exist.
@@ -170,7 +181,7 @@ module Liquid
         end
       end
 
-      result
+      output
     end
 
     def set_attribute(key, expr)
@@ -186,8 +197,18 @@ module Liquid
       end
     end
 
-    def render_else(context)
-      @else_block ? @else_block.render(context) : ''.freeze
+    def render_else(context, output)
+      if @else_block
+        @else_block.render_to_output_buffer(context, output)
+      else
+        output
+      end
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        (super + [@node.limit, @node.from, @node.collection_name]).compact
+      end
     end
   end
 

lib/liquid/tags/if.rb

@@ -12,7 +12,9 @@ module Liquid
   class If < Block
     Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
     ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS = %w(and or)
+    BOOLEAN_OPERATORS = %w(and or).freeze
+
+    attr_reader :blocks
 
     def initialize(tag_name, markup, options)
       super
@@ -20,15 +22,15 @@ module Liquid
       push_block('if'.freeze, markup)
     end
 
+    def nodelist
+      @blocks.map(&:attachment)
+    end
+
     def parse(tokens)
       while parse_body(@blocks.last.attachment, tokens)
       end
     end
 
-    def nodelist
-      @blocks.map(&:attachment)
-    end
-
     def unknown_tag(tag, markup, tokens)
       if ['elsif'.freeze, 'else'.freeze].include?(tag)
         push_block(tag, markup)
@@ -37,15 +39,16 @@ module Liquid
       end
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       context.stack do
         @blocks.each do |block|
           if block.evaluate(context)
-            return block.attachment.render(context)
+            return block.attachment.render_to_output_buffer(context, output)
           end
         end
-        ''.freeze
       end
+
+      output
     end
 
     private
@@ -83,17 +86,20 @@ module Liquid
 
     def strict_parse(markup)
       p = Parser.new(markup)
-      condition = parse_binary_comparison(p)
+      condition = parse_binary_comparisons(p)
       p.consume(:end_of_string)
       condition
     end
 
-    def parse_binary_comparison(p)
+    def parse_binary_comparisons(p)
       condition = parse_comparison(p)
-      if op = (p.id?('and'.freeze) || p.id?('or'.freeze))
-        condition.send(op, parse_binary_comparison(p))
+      first_condition = condition
+      while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
+        child_condition = parse_comparison(p)
+        condition.send(op, child_condition)
+        condition = child_condition
       end
-      condition
+      first_condition
     end
 
     def parse_comparison(p)
@@ -105,6 +111,12 @@ module Liquid
         Condition.new(a)
       end
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.blocks
+      end
+    end
   end
 
   Template.register_tag('if'.freeze, If)

lib/liquid/tags/ifchanged.rb

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

lib/liquid/tags/include.rb

@@ -16,6 +16,8 @@ module Liquid
   class Include < Tag
     Syntax = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?/o
 
+    attr_reader :template_name_expr, :variable_name_expr, :attributes
+
     def initialize(tag_name, markup, options)
       super
 
@@ -40,17 +42,22 @@ module Liquid
     def parse(_tokens)
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       template_name = context.evaluate(@template_name_expr)
       raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name
 
-      partial = load_cached_partial(template_name, context)
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context
+      )
+
       context_variable_name = template_name.split('/'.freeze).last
 
       variable = if @variable_name_expr
         context.evaluate(@variable_name_expr)
       else
-        context.find_variable(template_name)
+        context.find_variable(template_name, raise_on_not_found: false)
       end
 
       old_template_name = context.template_name
@@ -64,48 +71,33 @@ module Liquid
           end
 
           if variable.is_a?(Array)
-            variable.collect do |var|
+            variable.each do |var|
               context[context_variable_name] = var
-              partial.render(context)
+              partial.render_to_output_buffer(context, output)
             end
           else
             context[context_variable_name] = variable
-            partial.render(context)
+            partial.render_to_output_buffer(context, output)
           end
         end
       ensure
         context.template_name = old_template_name
         context.partial = old_partial
       end
-    end
 
-    private
+      output
+    end
 
     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
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.template_name_expr,
+          @node.variable_name_expr
+        ] + @node.attributes.values
       end
-      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 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
 

lib/liquid/tags/increment.rb

@@ -20,10 +20,12 @@ module Liquid
       @variable = markup.strip
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       value = context.environments.first[@variable] ||= 0
       context.environments.first[@variable] = value + 1
-      value.to_s
+
+      output << value.to_s
+      output
     end
   end
 

lib/liquid/tags/raw.rb

@@ -22,8 +22,9 @@ module Liquid
       raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
     end
 
-    def render(_context)
-      @body
+    def render_to_output_buffer(_context, output)
+      output << @body
+      output
     end
 
     def nodelist

lib/liquid/tags/render.rb

@@ -0,0 +1,54 @@
+module Liquid
+  class Render < Tag
+    Syntax = /(#{QuotedString})#{QuotedFragment}*/o
+
+    attr_reader :template_name_expr, :attributes
+
+    def initialize(tag_name, markup, options)
+      super
+
+      raise SyntaxError.new(options[:locale].t("errors.syntax.render".freeze)) unless markup =~ Syntax
+
+      template_name = $1
+
+      @template_name_expr = Expression.parse(template_name)
+
+      @attributes = {}
+      markup.scan(TagAttributes) do |key, value|
+        @attributes[key] = Expression.parse(value)
+      end
+    end
+
+    def render_to_output_buffer(context, output)
+      # Though we evaluate this here we will only ever parse it as a string literal.
+      template_name = context.evaluate(@template_name_expr)
+      raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name
+
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context
+      )
+
+      inner_context = context.new_isolated_subcontext
+      inner_context.template_name = template_name
+      inner_context.partial = true
+      @attributes.each do |key, value|
+        inner_context[key] = context.evaluate(value)
+      end
+      partial.render_to_output_buffer(inner_context, output)
+
+      output
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [
+          @node.template_name_expr,
+        ] + @node.attributes.values
+      end
+    end
+  end
+
+  Template.register_tag('render'.freeze, Render)
+end

lib/liquid/tags/table_row.rb

@@ -2,6 +2,8 @@ module Liquid
   class TableRow < Block
     Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
 
+    attr_reader :variable_name, :collection_name, :attributes
+
     def initialize(tag_name, markup, options)
       super
       if markup =~ Syntax
@@ -16,7 +18,7 @@ module Liquid
       end
     end
 
-    def render(context)
+    def render_to_output_buffer(context, output)
       collection = context.evaluate(@collection_name) or return ''.freeze
 
       from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
@@ -28,25 +30,34 @@ module Liquid
 
       cols = context.evaluate(@attributes['cols'.freeze]).to_i
 
-      result = "<tr class=\"row1\">\n"
+      output << "<tr class=\"row1\">\n"
       context.stack do
         tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
         context['tablerowloop'.freeze] = tablerowloop
 
-        collection.each_with_index do |item, index|
+        collection.each do |item|
           context[@variable_name] = item
 
-          result << "<td class=\"col#{tablerowloop.col}\">" << super << '</td>'
+          output << "<td class=\"col#{tablerowloop.col}\">"
+          super
+          output << '</td>'
 
           if tablerowloop.col_last && !tablerowloop.last
-            result << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
+            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
           end
 
           tablerowloop.send(:increment!)
         end
       end
-      result << "</tr>\n"
-      result
+
+      output << "</tr>\n"
+      output
+    end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        super + @node.attributes.values + [@node.collection_name]
+      end
     end
   end
 

lib/liquid/tags/unless.rb

@@ -6,23 +6,23 @@ module Liquid
   #   {% unless x < 0 %} x is greater than zero {% endunless %}
   #
   class Unless < If
-    def render(context)
+    def render_to_output_buffer(context, output)
       context.stack do
         # First condition is interpreted backwards ( if not )
         first_block = @blocks.first
         unless first_block.evaluate(context)
-          return first_block.attachment.render(context)
+          return first_block.attachment.render_to_output_buffer(context, output)
         end
 
         # After the first condition unless works just like if
         @blocks[1..-1].each do |block|
           if block.evaluate(context)
-            return block.attachment.render(context)
+            return block.attachment.render_to_output_buffer(context, output)
           end
         end
-
-        ''.freeze
       end
+
+      output
     end
   end
 

lib/liquid/template.rb

@@ -50,7 +50,7 @@ module Liquid
       private
 
       def lookup_class(name)
-        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
+        Object.const_get(name)
       end
     end
 
@@ -187,9 +187,12 @@ module Liquid
         raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
       end
 
+      output = nil
+
       case args.last
       when Hash
         options = args.pop
+        output = options[:output] if options[:output]
 
         registers.merge!(options[:registers]) if options[:registers].is_a?(Hash)
 
@@ -204,10 +207,9 @@ 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(context) do
-          @root.render(context)
+        with_profiling(context) do
+          @root.render_to_output_buffer(context, output || '')
         end
-        result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
       ensure
@@ -220,6 +222,10 @@ module Liquid
       render(*args)
     end
 
+    def render_to_output_buffer(context, output)
+      render(context, output: output)
+    end
+
     private
 
     def tokenize(source)

lib/liquid/tokenizer.rb

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

lib/liquid/usage.rb

@@ -0,0 +1,23 @@
+module Liquid
+  # Usage is used to store
+  class Usage
+    @messages = {}
+    class << self
+      def enable
+        Liquid::Context.send(:alias_method, :try_variable_find_in_environments, :try_variable_find_in_environments_usage)
+      end
+
+      def disable
+        Liquid::Context.send(:alias_method, :try_variable_find_in_environments, :try_variable_find_in_environments_original)
+      end
+
+      def track(message)
+        @messages[message] = true
+      end
+
+      def results
+        @messages
+      end
+    end
+  end
+end

lib/liquid/usages/try_variables.rb

@@ -0,0 +1,26 @@
+module Liquid
+  class Context
+    alias try_variable_find_in_environments_original try_variable_find_in_environments
+
+    def try_variable_find_in_environments_usage(key, raise_on_not_found:)
+      Usage.track("Using try_variable_find_in_environment")
+      @environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+
+        Usage.track("try_variable_find_in_environment reports Nil but responds to key") if environment.key?(key)
+      end
+      @static_environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+
+        Usage.track("try_variable_find_in_environment reports Nil but responds to key") if environment.key?(key)
+      end
+      nil
+    end
+  end
+end

lib/liquid/usages/usage_enabled.rb

@@ -0,0 +1 @@
+Liquid::Usage.track("Usage is enabled")

lib/liquid/utils.rb

@@ -46,11 +46,11 @@ module Liquid
     def self.to_number(obj)
       case obj
       when Float
-        BigDecimal.new(obj.to_s)
+        BigDecimal(obj.to_s)
       when Numeric
         obj
       when String
-        (obj.strip =~ /\A-?\d+\.\d+\z/) ? BigDecimal.new(obj) : obj.to_i
+        (obj.strip =~ /\A-?\d+\.\d+\z/) ? BigDecimal(obj) : obj.to_i
       else
         if obj.respond_to?(:to_number)
           obj.to_number

lib/liquid/variable.rb

@@ -10,10 +10,16 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
+    FilterMarkupRegex = /#{FilterSeparator}\s*(.*)/om
     FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
+    FilterArgsRegex = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
+    JustTagAttributes = /\A#{TagAttributes}\z/o
+    MarkupWithQuotedFragment = /(#{QuotedFragment})(.*)/om
+
     attr_accessor :filters, :name, :line_number
     attr_reader :parse_context
     alias_method :options, :parse_context
+
     include ParserSwitching
 
     def initialize(markup, parse_context)
@@ -35,17 +41,17 @@ module Liquid
 
     def lax_parse(markup)
       @filters = []
-      return unless markup =~ /(#{QuotedFragment})(.*)/om
+      return unless markup =~ MarkupWithQuotedFragment
 
       name_markup = $1
       filter_markup = $2
       @name = Expression.parse(name_markup)
-      if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
+      if filter_markup =~ FilterMarkupRegex
         filters = $1.scan(FilterParser)
         filters.each do |f|
           next unless f =~ /\w+/
           filtername = Regexp.last_match(0)
-          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
+          filterargs = f.scan(FilterArgsRegex).flatten
           @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
@@ -79,26 +85,38 @@ module Liquid
       end
 
       obj = context.apply_global_filter(obj)
-
       taint_check(context, obj)
-
       obj
     end
 
+    def render_to_output_buffer(context, output)
+      obj = render(context)
+
+      if obj.is_a?(Array)
+        output << obj.join
+      elsif obj.nil?
+      else
+        output << obj.to_s
+      end
+
+      output
+    end
+
     private
 
     def parse_filter_expressions(filter_name, unparsed_args)
       filter_args = []
-      keyword_args = {}
+      keyword_args = nil
       unparsed_args.each do |a|
-        if matches = a.match(/\A#{TagAttributes}\z/o)
+        if matches = a.match(JustTagAttributes)
+          keyword_args ||= {}
           keyword_args[matches[1]] = Expression.parse(matches[2])
         else
           filter_args << Expression.parse(a)
         end
       end
       result = [filter_name, filter_args]
-      result << keyword_args unless keyword_args.empty?
+      result << keyword_args if keyword_args
       result
     end
 
@@ -132,5 +150,11 @@ module Liquid
         raise error
       end
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.name] + @node.filters.flatten
+      end
+    end
   end
 end

lib/liquid/variable_lookup.rb

@@ -1,7 +1,7 @@
 module Liquid
   class VariableLookup
     SQUARE_BRACKETED = /\A\[(.*)\]\z/m
-    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
+    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze].freeze
 
     attr_reader :name, :lookups
 
@@ -78,5 +78,11 @@ module Liquid
     def state
       [@name, @lookups, @command_flags]
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        @node.lookups
+      end
+    end
   end
 end

lib/liquid/version.rb

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 module Liquid
-  VERSION = "4.0.0"
+  VERSION = "4.0.3".freeze
 end

liquid.gemspec

@@ -1,4 +1,5 @@
 # encoding: utf-8
+
 lib = File.expand_path('../lib/', __FILE__)
 $LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
 
@@ -15,7 +16,7 @@ Gem::Specification.new do |s|
   s.license     = "MIT"
   # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_ruby_version     = ">= 2.1.0"
+  s.required_ruby_version     = ">= 2.4.0"
   s.required_rubygems_version = ">= 1.3.7"
 
   s.test_files  = Dir.glob("{test}/**/*")

performance/benchmark.rb

@@ -5,7 +5,7 @@ Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 
 Benchmark.ips do |x|
-  x.time = 60
+  x.time = 10
   x.warmup = 5
 
   puts
@@ -13,5 +13,6 @@ Benchmark.ips do |x|
   puts
 
   x.report("parse:") { profiler.compile }
-  x.report("parse & run:") { profiler.run }
+  x.report("render:") { profiler.render }
+  x.report("parse & render:") { profiler.run }
 end

performance/memory_profile.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'benchmark/ips'
+require 'memory_profiler'
+require 'terminal-table'
+require_relative 'theme_runner'
+
+class Profiler
+  LOG_LABEL   = "Profiling: ".rjust(14).freeze
+  REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
+
+  def self.run
+    puts
+    yield new
+  end
+
+  def initialize
+    @allocated = []
+    @retained  = []
+    @headings  = []
+  end
+
+  def profile(phase, &block)
+    print LOG_LABEL
+    print "#{phase}.. ".ljust(10)
+    report = MemoryProfiler.report(&block)
+    puts 'Done.'
+    @headings  << phase.capitalize
+    @allocated << "#{report.scale_bytes(report.total_allocated_memsize)} (#{report.total_allocated} objects)"
+    @retained  << "#{report.scale_bytes(report.total_retained_memsize)} (#{report.total_retained} objects)"
+
+    return if ENV['CI']
+
+    require 'fileutils'
+    report_file = File.join(REPORTS_DIR, "#{sanitize(phase)}.txt")
+    FileUtils.mkdir_p(REPORTS_DIR)
+    report.pretty_print(to_file: report_file, scale_bytes: true)
+  end
+
+  def tabulate
+    table = Terminal::Table.new(headings: @headings.unshift('Phase')) do |t|
+      t << @allocated.unshift('Total allocated')
+      t << @retained.unshift('Total retained')
+    end
+
+    puts
+    puts table
+    puts "\nDetailed report(s) saved to #{REPORTS_DIR}/" unless ENV['CI']
+  end
+
+  def sanitize(string)
+    string.downcase.gsub(/[\W]/, '-').squeeze('-')
+  end
+end
+
+Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
+
+runner = ThemeRunner.new
+Profiler.run do |x|
+  x.profile('parse') { runner.compile }
+  x.profile('render') { runner.render }
+  x.tabulate
+end

performance/shopify/comment_form.rb

@@ -12,7 +12,7 @@ class CommentForm < Liquid::Block
     end
   end
 
-  def render(context)
+  def render_to_output_buffer(context, output)
     article = context[@variable_name]
 
     context.stack do
@@ -23,7 +23,9 @@ class CommentForm < Liquid::Block
         'email'  => context['comment.email'],
         'body'   => context['comment.body']
       }
-      wrap_in_form(article, render_all(@nodelist, context))
+
+      output << wrap_in_form(article, render_all(@nodelist, context, output))
+      output
     end
   end
 

performance/shopify/paginate.rb

@@ -21,7 +21,7 @@ class Paginate < Liquid::Block
     end
   end
 
-  def render(context)
+  def render_to_output_buffer(context, output)
     @context = context
 
     context.stack do

performance/theme_runner.rb

@@ -21,53 +21,100 @@ class ThemeRunner
     end
   end
 
-  # Load all templates into memory, do this now so that
-  # we don't profile IO.
+  # Initialize a new liquid ThemeRunner instance
+  # Will load all templates into memory, do this now so that we don't profile IO.
   def initialize
     @tests = Dir[__dir__ + '/tests/**/*.liquid'].collect do |test|
       next if File.basename(test) == 'theme.liquid'
 
       theme_path = File.dirname(test) + '/theme.liquid'
-
-      [File.read(test), (File.file?(theme_path) ? File.read(theme_path) : nil), test]
+      {
+        liquid: File.read(test),
+        layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
+        template_name: test
+      }
     end.compact
+
+    compile_all_tests
   end
 
+  # `compile` will test just the compilation portion of liquid without any templates
   def compile
-    # Dup assigns because will make some changes to them
-
-    @tests.each do |liquid, layout, template_name|
-      tmpl = Liquid::Template.new
-      tmpl.parse(liquid)
-      tmpl = Liquid::Template.new
-      tmpl.parse(layout)
+    @tests.each do |test_hash|
+      Liquid::Template.new.parse(test_hash[:liquid])
+      Liquid::Template.new.parse(test_hash[:layout])
     end
   end
 
+  # `run` is called to benchmark rendering and compiling at the same time
   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))
+    each_test do |liquid, layout, assigns, page_template, template_name|
       compile_and_render(liquid, layout, assigns, page_template, template_name)
     end
   end
 
+  # `render` is called to benchmark just the render portion of liquid
+  def render
+    @compiled_tests.each do |test|
+      tmpl = test[:tmpl]
+      assigns = test[:assigns]
+      layout = test[:layout]
+
+      if layout
+        assigns['content_for_layout'] = tmpl.render!(assigns)
+        layout.render!(assigns)
+      else
+        tmpl.render!(assigns)
+      end
+    end
+  end
+
+  private
+
   def compile_and_render(template, layout, assigns, page_template, template_file)
+    compiled_test = compile_test(template, layout, assigns, page_template, template_file)
+    assigns['content_for_layout'] = compiled_test[:tmpl].render!(assigns)
+    compiled_test[:layout].render!(assigns) if layout
+  end
+
+  def compile_all_tests
+    @compiled_tests = []
+    each_test do |liquid, layout, assigns, page_template, template_name|
+      @compiled_tests << compile_test(liquid, layout, assigns, page_template, template_name)
+    end
+    @compiled_tests
+  end
+
+  def compile_test(template, layout, assigns, page_template, template_file)
+    tmpl = init_template(page_template, template_file)
+    parsed_template = tmpl.parse(template).dup
+
+    if layout
+      parsed_layout = tmpl.parse(layout)
+      { tmpl: parsed_template, assigns: assigns, layout: parsed_layout }
+    else
+      { tmpl: parsed_template, assigns: assigns }
+    end
+  end
+
+  # utility method with similar functionality needed in `compile_all_tests` and `run`
+  def each_test
+    # Dup assigns because will make some changes to them
+    assigns = Database.tables.dup
+
+    @tests.each do |test_hash|
+      # Compute page_template outside of profiler run, uninteresting to profiler
+      page_template = File.basename(test_hash[:template_name], File.extname(test_hash[:template_name]))
+      yield(test_hash[:liquid], test_hash[:layout], assigns, page_template, test_hash[:template_name])
+    end
+  end
+
+  # set up a new Liquid::Template object for use in `compile_and_render` and `compile_test`
+  def init_template(page_template, template_file)
     tmpl = Liquid::Template.new
     tmpl.assigns['page_title'] = 'Page title'
     tmpl.assigns['template'] = page_template
     tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
-
-    content_for_layout = tmpl.parse(template).render!(assigns)
-
-    if layout
-      assigns['content_for_layout'] = content_for_layout
-      tmpl.parse(layout).render!(assigns)
-    else
-      content_for_layout
-    end
+    tmpl
   end
 end

test/integration/blank_test.rb

@@ -1,11 +1,10 @@
 require 'test_helper'
 
 class FoobarTag < Liquid::Tag
-  def render(*args)
-    " "
+  def render_to_output_buffer(context, output)
+    output << ' '
+    output
   end
-
-  Liquid::Template.register_tag('foobar', FoobarTag)
 end
 
 class BlankTestFileSystem
@@ -31,7 +30,9 @@ class BlankTest < Minitest::Test
   end
 
   def test_new_tags_are_not_blank_by_default
-    assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
+    with_custom_tag('foobar', FoobarTag) do
+      assert_template_result(" " * N, wrap_in_for("{% foobar %}"))
+    end
   end
 
   def test_loops_are_blank

test/integration/block_test.rb

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

test/integration/error_handling_test.rb

@@ -123,7 +123,7 @@ class ErrorHandlingTest < Minitest::Test
             ',
       error_mode: :warn,
       line_numbers: true
-                                     )
+    )
 
     assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
       template.warnings.map(&:message)
@@ -140,7 +140,7 @@ class ErrorHandlingTest < Minitest::Test
                 ',
         error_mode: :strict,
         line_numbers: true
-                            )
+      )
     end
 
     assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
@@ -158,7 +158,7 @@ class ErrorHandlingTest < Minitest::Test
           bla
                 ',
         line_numbers: true
-                            )
+      )
     end
 
     assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message

test/integration/parse_tree_visitor_test.rb

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

test/integration/parsing_quirks_test.rb

@@ -99,7 +99,7 @@ class ParsingQuirksTest < Minitest::Test
       # After the messed up quotes a filter without parameters (reverse) should work
       # but one with parameters (remove) shouldn't be detected.
       assert_template_result('here',  "{{ 'hi there' | split:\"t\"\" | reverse | first}}")
-      assert_template_result('hi ',  "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
+      assert_template_result('hi ', "{{ 'hi there' | split:\"t\"\" | remove:\"i\" | first}}")
     end
   end
 
@@ -115,4 +115,8 @@ class ParsingQuirksTest < Minitest::Test
       assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
     end
   end
+
+  def test_contains_in_id
+    assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
+  end
 end # ParsingQuirksTest

test/integration/security_test.rb

@@ -63,4 +63,18 @@ class SecurityTest < Minitest::Test
 
     assert_equal [], (Symbol.all_symbols - current_symbols)
   end
+
+  def test_max_depth_nested_blocks_does_not_raise_exception
+    depth = Liquid::Block::MAX_DEPTH
+    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
+    assert_equal "rendered", Template.parse(code).render!
+  end
+
+  def test_more_than_max_depth_nested_blocks_raises_exception
+    depth = Liquid::Block::MAX_DEPTH + 1
+    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
+    assert_raises(Liquid::StackLevelError) do
+      Template.parse(code).render!
+    end
+  end
 end # SecurityTest

test/integration/standard_filter_test.rb

@@ -128,8 +128,16 @@ class StandardFiltersTest < Minitest::Test
 
   def test_escape
     assert_equal '&lt;strong&gt;', @filters.escape('<strong>')
-    assert_equal nil, @filters.escape(nil)
+    assert_equal '1', @filters.escape(1)
+    assert_equal '2001-02-03', @filters.escape(Date.new(2001, 2, 3))
+    assert_nil @filters.escape(nil)
+  end
+
+  def test_h
     assert_equal '&lt;strong&gt;', @filters.h('<strong>')
+    assert_equal '1', @filters.h(1)
+    assert_equal '2001-02-03', @filters.h(Date.new(2001, 2, 3))
+    assert_nil @filters.h(nil)
   end
 
   def test_escape_once
@@ -138,14 +146,22 @@ class StandardFiltersTest < Minitest::Test
 
   def test_url_encode
     assert_equal 'foo%2B1%40example.com', @filters.url_encode('foo+1@example.com')
-    assert_equal nil, @filters.url_encode(nil)
+    assert_equal '1', @filters.url_encode(1)
+    assert_equal '2001-02-03', @filters.url_encode(Date.new(2001, 2, 3))
+    assert_nil @filters.url_encode(nil)
   end
 
   def test_url_decode
     assert_equal 'foo bar', @filters.url_decode('foo+bar')
     assert_equal 'foo bar', @filters.url_decode('foo%20bar')
     assert_equal 'foo+1@example.com', @filters.url_decode('foo%2B1%40example.com')
-    assert_equal nil, @filters.url_decode(nil)
+    assert_equal '1', @filters.url_decode(1)
+    assert_equal '2001-02-03', @filters.url_decode(Date.new(2001, 2, 3))
+    assert_nil @filters.url_decode(nil)
+    exception = assert_raises Liquid::ArgumentError do
+      @filters.url_decode('%ff')
+    end
+    assert_equal 'Liquid error: invalid byte sequence in UTF-8', exception.message
   end
 
   def test_truncatewords
@@ -165,11 +181,15 @@ class StandardFiltersTest < Minitest::Test
     assert_equal 'test', @filters.strip_html("<div\nclass='multiline'>test</div>")
     assert_equal 'test', @filters.strip_html("<!-- foo bar \n test -->test")
     assert_equal '', @filters.strip_html(nil)
+
+    # Quirk of the existing implementation
+    assert_equal 'foo;', @filters.strip_html("<<<script </script>script>foo;</script>")
   end
 
   def test_join
     assert_equal '1 2 3 4', @filters.join([1, 2, 3, 4])
     assert_equal '1 - 2 - 3 - 4', @filters.join([1, 2, 3, 4], ' - ')
+    assert_equal '1121314', @filters.join([1, 2, 3, 4], 1)
   end
 
   def test_sort
@@ -177,6 +197,11 @@ class StandardFiltersTest < Minitest::Test
     assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], @filters.sort([{ "a" => 4 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
   end
 
+  def test_sort_with_nils
+    assert_equal [1, 2, 3, 4, nil], @filters.sort([nil, 4, 3, 2, 1])
+    assert_equal [{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }, {}], @filters.sort([{ "a" => 4 }, { "a" => 3 }, {}, { "a" => 1 }, { "a" => 2 }], "a")
+  end
+
   def test_sort_when_property_is_sometimes_missing_puts_nils_last
     input = [
       { "price" => 4, "handle" => "alpha" },
@@ -195,14 +220,89 @@ class StandardFiltersTest < Minitest::Test
     assert_equal expectation, @filters.sort(input, "price")
   end
 
+  def test_sort_natural
+    assert_equal ["a", "B", "c", "D"], @filters.sort_natural(["c", "D", "a", "B"])
+    assert_equal [{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, { "a" => "a" }, { "a" => "B" }], "a")
+  end
+
+  def test_sort_natural_with_nils
+    assert_equal ["a", "B", "c", "D", nil], @filters.sort_natural([nil, "c", "D", "a", "B"])
+    assert_equal [{ "a" => "a" }, { "a" => "B" }, { "a" => "c" }, { "a" => "D" }, {}], @filters.sort_natural([{ "a" => "D" }, { "a" => "c" }, {}, { "a" => "a" }, { "a" => "B" }], "a")
+  end
+
+  def test_sort_natural_when_property_is_sometimes_missing_puts_nils_last
+    input = [
+      { "price" => "4", "handle" => "alpha" },
+      { "handle" => "beta" },
+      { "price" => "1", "handle" => "gamma" },
+      { "handle" => "delta" },
+      { "price" => 2, "handle" => "epsilon" }
+    ]
+    expectation = [
+      { "price" => "1", "handle" => "gamma" },
+      { "price" => 2, "handle" => "epsilon" },
+      { "price" => "4", "handle" => "alpha" },
+      { "handle" => "delta" },
+      { "handle" => "beta" }
+    ]
+    assert_equal expectation, @filters.sort_natural(input, "price")
+  end
+
+  def test_sort_natural_case_check
+    input = [
+      { "key" => "X" },
+      { "key" => "Y" },
+      { "key" => "Z" },
+      { "fake" => "t" },
+      { "key" => "a" },
+      { "key" => "b" },
+      { "key" => "c" }
+    ]
+    expectation = [
+      { "key" => "a" },
+      { "key" => "b" },
+      { "key" => "c" },
+      { "key" => "X" },
+      { "key" => "Y" },
+      { "key" => "Z" },
+      { "fake" => "t" }
+    ]
+    assert_equal expectation, @filters.sort_natural(input, "key")
+    assert_equal ["a", "b", "c", "X", "Y", "Z"], @filters.sort_natural(["X", "Y", "Z", "a", "b", "c"])
+  end
+
   def test_sort_empty_array
     assert_equal [], @filters.sort([], "a")
   end
 
+  def test_sort_invalid_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.sort(foo, "bar")
+    end
+  end
+
   def test_sort_natural_empty_array
     assert_equal [], @filters.sort_natural([], "a")
   end
 
+  def test_sort_natural_invalid_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.sort_natural(foo, "bar")
+    end
+  end
+
   def test_legacy_sort_hash
     assert_equal [{ a: 1, b: 2 }], @filters.sort({ a: 1, b: 2 })
   end
@@ -226,10 +326,34 @@ class StandardFiltersTest < Minitest::Test
     assert_equal [], @filters.uniq([], "a")
   end
 
+  def test_uniq_invalid_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.uniq(foo, "bar")
+    end
+  end
+
   def test_compact_empty_array
     assert_equal [], @filters.compact([], "a")
   end
 
+  def test_compact_invalid_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.compact(foo, "bar")
+    end
+  end
+
   def test_reverse
     assert_equal [4, 3, 2, 1], @filters.reverse([1, 2, 3, 4])
   end
@@ -295,6 +419,29 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result "123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new
   end
 
+  def test_map_returns_empty_on_2d_input_array
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+
+    assert_raises Liquid::ArgumentError do
+      @filters.map(foo, "bar")
+    end
+  end
+
+  def test_map_returns_empty_with_no_property
+    foo = [
+      [1],
+      [2],
+      [3]
+    ]
+    assert_raises Liquid::ArgumentError do
+      @filters.map(foo, nil)
+    end
+  end
+
   def test_sort_works_on_enumerables
     assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
   end
@@ -325,11 +472,11 @@ class StandardFiltersTest < Minitest::Test
     assert_equal '07/05/2006', @filters.date("2006-07-05 10:00:00", "%m/%d/%Y")
 
     assert_equal "07/16/2004", @filters.date("Fri Jul 16 01:00:00 2004", "%m/%d/%Y")
-    assert_equal "#{Date.today.year}", @filters.date('now', '%Y')
-    assert_equal "#{Date.today.year}", @filters.date('today', '%Y')
-    assert_equal "#{Date.today.year}", @filters.date('Today', '%Y')
+    assert_equal Date.today.year.to_s, @filters.date('now', '%Y')
+    assert_equal Date.today.year.to_s, @filters.date('today', '%Y')
+    assert_equal Date.today.year.to_s, @filters.date('Today', '%Y')
 
-    assert_equal nil, @filters.date(nil, "%B")
+    assert_nil @filters.date(nil, "%B")
 
     assert_equal '', @filters.date('', "%B")
 
@@ -342,8 +489,8 @@ class StandardFiltersTest < Minitest::Test
   def test_first_last
     assert_equal 1, @filters.first([1, 2, 3])
     assert_equal 3, @filters.last([1, 2, 3])
-    assert_equal nil, @filters.first([])
-    assert_equal nil, @filters.last([])
+    assert_nil @filters.first([])
+    assert_nil @filters.last([])
   end
 
   def test_replace
@@ -483,6 +630,28 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result "5", "{{ price | floor }}", 'price' => NumberLikeThing.new(5.4)
   end
 
+  def test_at_most
+    assert_template_result "4", "{{ 5 | at_most:4 }}"
+    assert_template_result "5", "{{ 5 | at_most:5 }}"
+    assert_template_result "5", "{{ 5 | at_most:6 }}"
+
+    assert_template_result "4.5", "{{ 4.5 | at_most:5 }}"
+    assert_template_result "5", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(6)
+    assert_template_result "4", "{{ width | at_most:5 }}", 'width' => NumberLikeThing.new(4)
+    assert_template_result "4", "{{ 5 | at_most: width }}", 'width' => NumberLikeThing.new(4)
+  end
+
+  def test_at_least
+    assert_template_result "5", "{{ 5 | at_least:4 }}"
+    assert_template_result "5", "{{ 5 | at_least:5 }}"
+    assert_template_result "6", "{{ 5 | at_least:6 }}"
+
+    assert_template_result "5", "{{ 4.5 | at_least:5 }}"
+    assert_template_result "6", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(6)
+    assert_template_result "5", "{{ width | at_least:5 }}", 'width' => NumberLikeThing.new(4)
+    assert_template_result "6", "{{ 5 | at_least: width }}", 'width' => NumberLikeThing.new(6)
+  end
+
   def test_append
     assigns = { 'a' => 'bc', 'b' => 'd' }
     assert_template_result('bcd', "{{ a | append: 'd'}}", assigns)
@@ -523,6 +692,78 @@ class StandardFiltersTest < Minitest::Test
     assert_template_result('abc', "{{ 'abc' | date: '%D' }}")
   end
 
+  def test_where
+    input = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta", "ok" => false },
+      { "handle" => "gamma", "ok" => false },
+      { "handle" => "delta", "ok" => true }
+    ]
+
+    expectation = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "delta", "ok" => true }
+    ]
+
+    assert_equal expectation, @filters.where(input, "ok", true)
+    assert_equal expectation, @filters.where(input, "ok")
+  end
+
+  def test_where_no_key_set
+    input = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta" },
+      { "handle" => "gamma" },
+      { "handle" => "delta", "ok" => true }
+    ]
+
+    expectation = [
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "delta", "ok" => true }
+    ]
+
+    assert_equal expectation, @filters.where(input, "ok", true)
+    assert_equal expectation, @filters.where(input, "ok")
+  end
+
+  def test_where_non_array_map_input
+    assert_equal [{ "a" => "ok" }], @filters.where({ "a" => "ok" }, "a", "ok")
+    assert_equal [], @filters.where({ "a" => "not ok" }, "a", "ok")
+  end
+
+  def test_where_indexable_but_non_map_value
+    assert_raises(Liquid::ArgumentError) { @filters.where(1, "ok", true) }
+    assert_raises(Liquid::ArgumentError) { @filters.where(1, "ok") }
+  end
+
+  def test_where_non_boolean_value
+    input = [
+      { "message" => "Bonjour!", "language" => "French" },
+      { "message" => "Hello!", "language" => "English" },
+      { "message" => "Hallo!", "language" => "German" }
+    ]
+
+    assert_equal [{ "message" => "Bonjour!", "language" => "French" }], @filters.where(input, "language", "French")
+    assert_equal [{ "message" => "Hallo!", "language" => "German" }], @filters.where(input, "language", "German")
+    assert_equal [{ "message" => "Hello!", "language" => "English" }], @filters.where(input, "language", "English")
+  end
+
+  def test_where_array_of_only_unindexable_values
+    assert_nil @filters.where([nil], "ok", true)
+    assert_nil @filters.where([nil], "ok")
+  end
+
+  def test_where_no_target_value
+    input = [
+      { "foo" => false },
+      { "foo" => true },
+      { "foo" => "for sure" },
+      { "bar" => true }
+    ]
+
+    assert_equal [{ "foo" => true }, { "foo" => "for sure" }], @filters.where(input, "foo")
+  end
+
   private
 
   def with_timezone(tz)

test/integration/tags/echo_test.rb

@@ -0,0 +1,11 @@
+require 'test_helper'
+
+class EchoTest < Minitest::Test
+  include Liquid
+
+  def test_echo_outputs_its_input
+    assert_template_result('BAR', <<~LIQUID, { 'variable-name' => 'bar' })
+      {%- echo variable-name | upcase -%}
+    LIQUID
+  end
+end

test/integration/tags/for_tag_test.rb

@@ -103,6 +103,34 @@ HERE
     assert_template_result('3456', '{%for i in array limit: 4 offset: 2 %}{{ i }}{%endfor%}', assigns)
   end
 
+  def test_limiting_with_invalid_limit
+    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
+    template = <<-MKUP
+      {% for i in array limit: true offset: 1 %}
+        {{ i }}
+      {% endfor %}
+    MKUP
+
+    exception = assert_raises(Liquid::ArgumentError) do
+      Template.parse(template).render!(assigns)
+    end
+    assert_equal("Liquid error: invalid integer", exception.message)
+  end
+
+  def test_limiting_with_invalid_offset
+    assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
+    template = <<-MKUP
+      {% for i in array limit: 1 offset: true %}
+        {{ i }}
+      {% endfor %}
+    MKUP
+
+    exception = assert_raises(Liquid::ArgumentError) do
+      Template.parse(template).render!(assigns)
+    end
+    assert_equal("Liquid error: invalid integer", exception.message)
+  end
+
   def test_dynamic_variable_limiting
     assigns = { 'array' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] }
     assigns['limit'] = 2
@@ -159,7 +187,7 @@ HERE
     assert_template_result(expected, markup, assigns)
   end
 
-  def test_pause_resume_BIG_limit
+  def test_pause_resume_big_limit
     assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
     markup = <<-MKUP
       {%for i in array.items limit:3 %}{{i}}{%endfor%}
@@ -178,7 +206,7 @@ HERE
     assert_template_result(expected, markup, assigns)
   end
 
-  def test_pause_resume_BIG_offset
+  def test_pause_resume_big_offset
     assigns = { 'array' => { 'items' => [1, 2, 3, 4, 5, 6, 7, 8, 9, 0] } }
     markup = '{%for i in array.items limit:3 %}{{i}}{%endfor%}
       next

test/integration/tags/include_tag_test.rb

@@ -30,6 +30,9 @@ class TestFileSystem
     when 'assignments'
       "{% assign foo = 'bar' %}"
 
+    when 'break'
+      "{% break %}"
+
     else
       template_path
     end
@@ -63,8 +66,9 @@ class CustomInclude < Liquid::Tag
   def parse(tokens)
   end
 
-  def render(context)
-    @template_name[1..-2]
+  def render_to_output_buffer(context, output)
+    output << @template_name[1..-2]
+    output
   end
 end
 
@@ -137,7 +141,7 @@ class IncludeTagTest < Minitest::Test
 
     Liquid::Template.file_system = infinite_file_system.new
 
-    assert_raises(Liquid::StackLevelError, SystemStackError) do
+    assert_raises(Liquid::StackLevelError) do
       Template.parse("{% include 'loop' %}").render!
     end
   end
@@ -235,4 +239,16 @@ class IncludeTagTest < Minitest::Test
 
     assert_template_result "Product: Draft 151cm ", "{% assign page = 'product' %}{% include page for foo %}", "foo" => { 'title' => 'Draft 151cm' }
   end
+
+  def test_including_with_strict_variables
+    template = Liquid::Template.parse("{% include 'simple' %}", error_mode: :warn)
+    template.render(nil, strict_variables: true)
+
+    assert_equal [], template.errors
+  end
+
+  def test_break_through_include
+    assert_template_result "1", "{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}"
+    assert_template_result "1", "{% for i in (1..3) %}{{ i }}{% include 'break' %}{{ i }}{% endfor %}"
+  end
 end # IncludeTagTest

test/integration/tags/liquid_tag_test.rb

@@ -0,0 +1,104 @@
+require 'test_helper'
+
+class LiquidTagTest < Minitest::Test
+  include Liquid
+
+  def test_liquid_tag
+    assert_template_result('1 2 3', <<~LIQUID, 'array' => [1, 2, 3])
+      {%- liquid
+        echo array | join: " "
+      -%}
+    LIQUID
+
+    assert_template_result('1 2 3', <<~LIQUID, 'array' => [1, 2, 3])
+      {%- liquid
+        for value in array
+          echo value
+          unless forloop.last
+            echo " "
+          endunless
+        endfor
+      -%}
+    LIQUID
+
+    assert_template_result('4 8 12 6', <<~LIQUID, 'array' => [1, 2, 3])
+      {%- liquid
+        for value in array
+          assign double_value = value | times: 2
+          echo double_value | times: 2
+          unless forloop.last
+            echo " "
+          endunless
+        endfor
+
+        echo " "
+        echo double_value
+      -%}
+    LIQUID
+
+    assert_template_result('abc', <<~LIQUID)
+      {%- liquid echo "a" -%}
+      b
+      {%- liquid echo "c" -%}
+    LIQUID
+  end
+
+  def test_liquid_tag_errors
+    assert_match_syntax_error("syntax error (line 1): Unknown tag 'error'", <<~LIQUID)
+      {%- liquid error no such tag -%}
+    LIQUID
+
+    assert_match_syntax_error("syntax error (line 7): Unknown tag 'error'", <<~LIQUID)
+      {{ test }}
+
+      {%-
+      liquid
+        for value in array
+
+          error no such tag
+        endfor
+      -%}
+    LIQUID
+
+    assert_match_syntax_error("syntax error (line 2): Unknown tag '!!! the guards are vigilant'", <<~LIQUID)
+      {%- liquid
+        !!! the guards are vigilant
+      -%}
+    LIQUID
+
+    assert_match_syntax_error("syntax error (line 4): 'for' tag was never closed", <<~LIQUID)
+      {%- liquid
+        for value in array
+          echo 'forgot to close the for tag'
+      -%}
+    LIQUID
+  end
+
+  def test_line_number_is_correct_after_a_blank_token
+    assert_match_syntax_error("syntax error (line 3): Unknown tag 'error'", "{% liquid echo ''\n\n error %}")
+    assert_match_syntax_error("syntax error (line 3): Unknown tag 'error'", "{% liquid echo ''\n  \n error %}")
+  end
+
+  def test_cannot_open_blocks_living_past_a_liquid_tag
+    assert_match_syntax_error("syntax error (line 3): 'if' tag was never closed", <<~LIQUID)
+      {%- liquid
+        if true
+      -%}
+      {%- endif -%}
+    LIQUID
+  end
+
+  def test_quirk_can_close_blocks_created_before_a_liquid_tag
+    assert_template_result("42", <<~LIQUID)
+      {%- if true -%}
+      42
+      {%- liquid endif -%}
+    LIQUID
+  end
+
+  def test_liquid_tag_in_raw
+    assert_template_result("{% liquid echo 'test' %}\n", <<~LIQUID)
+      {% raw %}{% liquid echo 'test' %}{% endraw %}
+    LIQUID
+  end
+end

test/integration/tags/render_tag_test.rb

@@ -0,0 +1,149 @@
+require 'test_helper'
+
+class RenderTagTest < Minitest::Test
+  include Liquid
+
+  def test_render_with_no_arguments
+    Liquid::Template.file_system = StubFileSystem.new('source' => 'rendered content')
+    assert_template_result 'rendered content', '{% render "source" %}'
+  end
+
+  def test_render_tag_looks_for_file_system_in_registers_first
+    file_system = StubFileSystem.new('pick_a_source' => 'from register file system')
+    assert_equal 'from register file system',
+      Template.parse('{% render "pick_a_source" %}').render!({}, registers: { file_system: file_system })
+  end
+
+  def test_render_passes_named_arguments_into_inner_scope
+    Liquid::Template.file_system = StubFileSystem.new('product' => '{{ inner_product.title }}')
+    assert_template_result 'My Product', '{% render "product", inner_product: outer_product %}',
+      'outer_product' => { 'title' => 'My Product' }
+  end
+
+  def test_render_accepts_literals_as_arguments
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ price }}')
+    assert_template_result '123', '{% render "snippet", price: 123 %}'
+  end
+
+  def test_render_accepts_multiple_named_arguments
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ one }} {{ two }}')
+    assert_template_result '1 2', '{% render "snippet", one: 1, two: 2 %}'
+  end
+
+  def test_render_does_not_inherit_parent_scope_variables
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ outer_variable }}')
+    assert_template_result '', '{% assign outer_variable = "should not be visible" %}{% render "snippet" %}'
+  end
+
+  def test_render_does_not_inherit_variable_with_same_name_as_snippet
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ snippet }}')
+    assert_template_result '', "{% assign snippet = 'should not be visible' %}{% render 'snippet' %}"
+  end
+
+  def test_render_sets_the_correct_template_name_for_errors
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
+
+    with_taint_mode :error do
+      template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
+      context = Context.new('unsafe' => (+'unsafe').tap(&:taint))
+      template.render(context)
+
+      assert_equal [Liquid::TaintedError], template.errors.map(&:class)
+      assert_equal 'snippet', template.errors.first.template_name
+    end
+  end
+
+  def test_render_sets_the_correct_template_name_for_warnings
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{{ unsafe }}')
+
+    with_taint_mode :warn do
+      template = Liquid::Template.parse('{% render "snippet", unsafe: unsafe %}')
+      context = Context.new('unsafe' => (+'unsafe').tap(&:taint))
+      template.render(context)
+
+      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
+      assert_equal 'snippet', context.warnings.first.template_name
+    end
+  end
+
+  def test_render_does_not_mutate_parent_scope
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => '{% assign inner = 1 %}')
+    assert_template_result '', "{% render 'snippet' %}{{ inner }}"
+  end
+
+  def test_nested_render_tag
+    Liquid::Template.file_system = StubFileSystem.new(
+      'one' => "one {% render 'two' %}",
+      'two' => 'two'
+    )
+    assert_template_result 'one two', "{% render 'one' %}"
+  end
+
+  def test_recursively_rendered_template_does_not_produce_endless_loop
+    Liquid::Template.file_system = StubFileSystem.new('loop' => '{% render "loop" %}')
+
+    assert_raises Liquid::StackLevelError do
+      Template.parse('{% render "loop" %}').render!
+    end
+  end
+
+  def test_includes_and_renders_count_towards_the_same_recursion_limit
+    Liquid::Template.file_system = StubFileSystem.new(
+      'loop_render' => '{% render "loop_include" %}',
+      'loop_include' => '{% include "loop_render" %}'
+    )
+
+    assert_raises Liquid::StackLevelError  do
+      Template.parse('{% render "loop_include" %}').render!
+    end
+  end
+
+  def test_dynamically_choosen_templates_are_not_allowed
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'should not be rendered')
+
+    assert_raises Liquid::SyntaxError do
+      Liquid::Template.parse("{% assign name = 'snippet' %}{% render name %}")
+    end
+  end
+
+  def test_include_tag_caches_second_read_of_same_partial
+    file_system = StubFileSystem.new('snippet' => 'echo')
+    assert_equal 'echoecho',
+      Template.parse('{% render "snippet" %}{% render "snippet" %}')
+              .render!({}, registers: { file_system: file_system })
+    assert_equal 1, file_system.file_read_count
+  end
+
+  def test_render_tag_doesnt_cache_partials_across_renders
+    file_system = StubFileSystem.new('snippet' => 'my message')
+
+    assert_equal 'my message',
+      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system })
+    assert_equal 1, file_system.file_read_count
+
+    assert_equal 'my message',
+      Template.parse('{% include "snippet" %}').render!({}, registers: { file_system: file_system })
+    assert_equal 2, file_system.file_read_count
+  end
+
+  def test_render_tag_within_if_statement
+    Liquid::Template.file_system = StubFileSystem.new('snippet' => 'my message')
+    assert_template_result 'my message', '{% if true %}{% render "snippet" %}{% endif %}'
+  end
+
+  def test_break_through_render
+    Liquid::Template.file_system = StubFileSystem.new('break' => '{% break %}')
+    assert_template_result '1', '{% for i in (1..3) %}{{ i }}{% break %}{{ i }}{% endfor %}'
+    assert_template_result '112233', '{% for i in (1..3) %}{{ i }}{% render "break" %}{{ i }}{% endfor %}'
+  end
+
+  def test_increment_is_isolated_between_renders
+    Liquid::Template.file_system = StubFileSystem.new('incr' => '{% increment %}')
+    assert_template_result '010', '{% increment %}{% increment %}{% render "incr" %}'
+  end
+
+  def test_decrement_is_isolated_between_renders
+    Liquid::Template.file_system = StubFileSystem.new('decr' => '{% decrement %}')
+    assert_template_result '-1-2-1', '{% decrement %}{% decrement %}{% render "decr" %}'
+  end
+end

test/integration/template_test.rb

@@ -139,6 +139,16 @@ class TemplateTest < Minitest::Test
     refute_nil t.resource_limits.assign_score
   end
 
+  def test_resource_limits_assign_score_counts_bytes_not_characters
+    t = Template.parse("{% assign foo = 'すごい' %}")
+    t.render
+    assert_equal 9, t.resource_limits.assign_score
+
+    t = Template.parse("{% capture foo %}すごい{% endcapture %}")
+    t.render
+    assert_equal 9, t.resource_limits.assign_score
+  end
+
   def test_resource_limits_assign_score_nested
     t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
 
@@ -187,6 +197,14 @@ class TemplateTest < Minitest::Test
     assert_equal "ababab", t.render
   end
 
+  def test_render_length_uses_number_of_bytes_not_characters
+    t = Template.parse("{% if true %}すごい{% endif %}")
+    t.resource_limits.render_length_limit = 10
+    assert_equal "Liquid error: Memory limits exceeded", t.render
+    t.resource_limits.render_length_limit = 18
+    assert_equal "すごい", t.render
+  end
+
   def test_default_resource_limits_unaffected_by_render_with_context
     context = Context.new
     t = Template.parse("{% for a in (1..100) %} {% assign foo = 1 %} {% endfor %}")
@@ -261,6 +279,15 @@ class TemplateTest < Minitest::Test
     assert_equal 'Liquid error: undefined variable d', t.errors[2].message
   end
 
+  def test_nil_value_does_not_raise
+    Liquid::Template.error_mode = :strict
+    t = Template.parse("some{{x}}thing")
+    result = t.render!({ 'x' => nil }, strict_variables: true)
+
+    assert_equal 0, t.errors.count
+    assert_equal 'something', result
+  end
+
   def test_undefined_variables_raise
     t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
 

test/integration/trim_mode_test.rb

@@ -496,6 +496,10 @@ class TrimModeTest < Minitest::Test
     assert_template_result(expected, text)
   end
 
+  def test_right_trim_followed_by_tag
+    assert_template_result('ab c', '{{ "a" -}}{{ "b" }} c')
+  end
+
   def test_raw_output
     whitespace = '        '
     text = <<-END_TEMPLATE

test/integration/usages/try_variables_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+class TryVariablesUsageTest < Minitest::Test
+  include Liquid
+
+  def test_test_usages
+    Usage.enable
+    template = Template.parse(%({{test}}))
+    assert_equal 'worked', template.render!('test' => 'worked')
+    assert_equal 'worked wonderfully', template.render!('test' => 'worked wonderfully')
+    assert_equal true, Usage.results["Using try_variable_find_in_environment"]
+    Usage.disable
+  end
+end

test/integration/usages/usage_enabled_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class UsageEnabledUsageTest < Minitest::Test
+  include Liquid
+
+  def test_live_usages
+    assert_equal true, Usage.results["Usage is enabled"]
+  end
+end

test/integration/variable_test.rb

@@ -89,4 +89,8 @@ class VariableTest < Minitest::Test
   def test_multiline_variable
     assert_equal 'worked', Template.parse("{{\ntest\n}}").render!('test' => 'worked')
   end
+
+  def test_render_symbol
+    assert_template_result 'bar', '{{ foo }}', 'foo' => :bar
+  end
 end

test/test_helper.rb

@@ -2,7 +2,6 @@
 
 ENV["MT_NO_EXPECTATIONS"] = "1"
 require 'minitest/autorun'
-require 'spy/integration'
 
 $LOAD_PATH.unshift(File.join(File.expand_path(__dir__), '..', 'lib'))
 require 'liquid.rb'
@@ -15,7 +14,7 @@ if env_mode = ENV['LIQUID_PARSER_MODE']
 end
 Liquid::Template.error_mode = mode
 
-if ENV['LIQUID-C'] == '1'
+if ENV['LIQUID_C'] == '1'
   puts "-- LIQUID C"
   require 'liquid/c'
 end
@@ -38,18 +37,18 @@ module Minitest
     include Liquid
 
     def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template).render!(assigns), message
+      assert_equal expected, Template.parse(template, line_numbers: true).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), message
+      assert_match expected, Template.parse(template, line_numbers: true).render!(assigns), message
     end
 
     def assert_match_syntax_error(match, template, assigns = {})
       exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template).render(assigns)
+        Template.parse(template, line_numbers: true).render(assigns)
       end
       assert_match match, exception.message
     end
@@ -85,6 +84,13 @@ module Minitest
     ensure
       Liquid::Template.error_mode = old_mode
     end
+
+    def with_custom_tag(tag_name, tag_class)
+      Liquid::Template.register_tag(tag_name, tag_class)
+      yield
+    ensure
+      Liquid::Template.tags.delete(tag_name)
+    end
   end
 end
 
@@ -115,3 +121,17 @@ class ErrorDrop < Liquid::Drop
     raise Exception, 'exception'
   end
 end
+
+class StubFileSystem
+  attr_reader :file_read_count
+
+  def initialize(values)
+    @file_read_count = 0
+    @values = values
+  end
+
+  def read_template_file(template_path)
+    @file_read_count += 1
+    @values.fetch(template_path)
+  end
+end

test/unit/block_unit_test.rb

@@ -44,10 +44,47 @@ class BlockUnitTest < Minitest::Test
   end
 
   def test_with_custom_tag
-    Liquid::Template.register_tag("testtag", Block)
-    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
-  ensure
-    Liquid::Template.tags.delete('testtag')
+    with_custom_tag('testtag', Block) do
+      assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
+    end
+  end
+
+  def test_custom_block_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
+    klass1 = Class.new(Block) do
+      def render(*)
+        'hello'
+      end
+    end
+
+    with_custom_tag('blabla', klass1) do
+      template = Liquid::Template.parse("{% blabla %} bla {% endblabla %}")
+
+      assert_equal 'hello', template.render
+
+      buf = ''
+      output = template.render({}, output: buf)
+      assert_equal 'hello', output
+      assert_equal 'hello', buf
+      assert_equal buf.object_id, output.object_id
+    end
+
+    klass2 = Class.new(klass1) do
+      def render(*)
+        'foo' + super + 'bar'
+      end
+    end
+
+    with_custom_tag('blabla', klass2) do
+      template = Liquid::Template.parse("{% blabla %} foo {% endblabla %}")
+
+      assert_equal 'foohellobar', template.render
+
+      buf = ''
+      output = template.render({}, output: buf)
+      assert_equal 'foohellobar', output
+      assert_equal 'foohellobar', buf
+      assert_equal buf.object_id, output.object_id
+    end
   end
 
   private

test/unit/condition_unit_test.rb

@@ -24,9 +24,9 @@ class ConditionUnitTest < Minitest::Test
     assert_evaluates_true 1, '<=', 1
     # negative numbers
     assert_evaluates_true 1, '>', -1
-    assert_evaluates_true (-1), '<', 1
+    assert_evaluates_true -1, '<', 1
     assert_evaluates_true 1.0, '>', -1.0
-    assert_evaluates_true (-1.0), '<', 1.0
+    assert_evaluates_true -1.0, '<', 1.0
   end
 
   def test_default_operators_evalute_false
@@ -64,6 +64,14 @@ class ConditionUnitTest < Minitest::Test
     assert_evaluates_argument_error '1', '<=', 0
   end
 
+  def test_hash_compare_backwards_compatibility
+    assert_nil Condition.new({}, '>', 2).evaluate
+    assert_nil Condition.new(2, '>', {}).evaluate
+    assert_equal false, Condition.new({}, '==', 2).evaluate
+    assert_equal true, Condition.new({ 'a' => 1 }, '==', { 'a' => 1 }).evaluate
+    assert_equal true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate
+  end
+
   def test_contains_works_on_arrays
     @context = Liquid::Context.new
     @context['array'] = [1, 2, 3, 4, 5]

test/unit/context_unit_test.rb

@@ -70,10 +70,6 @@ class ContextUnitTest < Minitest::Test
     @context = Liquid::Context.new
   end
 
-  def teardown
-    Spy.teardown
-  end
-
   def test_variables
     @context['string'] = 'string'
     assert_equal 'string', @context['string']
@@ -98,12 +94,12 @@ class ContextUnitTest < Minitest::Test
     assert_equal false, @context['bool']
 
     @context['nil'] = nil
-    assert_equal nil, @context['nil']
-    assert_equal nil, @context['nil']
+    assert_nil @context['nil']
+    assert_nil @context['nil']
   end
 
   def test_variables_not_existing
-    assert_equal nil, @context['does_not_exist']
+    assert_nil @context['does_not_exist']
   end
 
   def test_scoping
@@ -185,7 +181,7 @@ class ContextUnitTest < Minitest::Test
     @context['test'] = 'test'
     assert_equal 'test', @context['test']
     @context.pop
-    assert_equal nil, @context['test']
+    assert_nil @context['test']
   end
 
   def test_hierachical_data
@@ -300,7 +296,7 @@ class ContextUnitTest < Minitest::Test
     @context['hash'] = { 'first' => 'Hello' }
 
     assert_equal 1, @context['array.first']
-    assert_equal nil, @context['array["first"]']
+    assert_nil @context['array["first"]']
     assert_equal 'Hello', @context['hash["first"]']
   end
 
@@ -450,14 +446,10 @@ class ContextUnitTest < Minitest::Test
     assert_equal @context, @context['category'].context
   end
 
-  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?)
-
-    @context.interrupt?
-
-    refute mock_any.has_been_called?
-    assert mock_empty.has_been_called?
+  def test_interrupt_avoids_object_allocations
+    assert_no_object_allocations do
+      @context.interrupt?
+    end
   end
 
   def test_context_initialization_with_a_proc_in_environment
@@ -476,8 +468,90 @@ class ContextUnitTest < Minitest::Test
     assert_equal 'hi filtered', context.apply_global_filter('hi')
   end
 
+  def test_static_environments_are_read_with_lower_priority_than_environments
+    context = Context.build(
+      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
+      environments: { 'shadowed' => 'dynamic' }
+    )
+
+    assert_equal 'dynamic', context['shadowed']
+    assert_equal 'static', context['unshadowed']
+  end
+
   def test_apply_global_filter_when_no_global_filter_exist
     context = Context.new
     assert_equal 'hi', context.apply_global_filter('hi')
   end
+
+  def test_new_isolated_subcontext_does_not_inherit_variables
+    super_context = Context.new
+    super_context['my_variable'] = 'some value'
+    subcontext = super_context.new_isolated_subcontext
+
+    assert_nil subcontext['my_variable']
+  end
+
+  def test_new_isolated_subcontext_inherits_static_environment
+    super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
+    subcontext = super_context.new_isolated_subcontext
+
+    assert_equal 'my value', subcontext['my_environment_value']
+  end
+
+  def test_new_isolated_subcontext_inherits_resource_limits
+    resource_limits = ResourceLimits.new({})
+    super_context = Context.new({}, {}, {}, false, resource_limits)
+    subcontext = super_context.new_isolated_subcontext
+    assert_equal resource_limits, subcontext.resource_limits
+  end
+
+  def test_new_isolated_subcontext_inherits_exception_renderer
+    super_context = Context.new
+    super_context.exception_renderer = ->(_e) { 'my exception message' }
+    subcontext = super_context.new_isolated_subcontext
+    assert_equal 'my exception message', subcontext.handle_error(Liquid::Error.new)
+  end
+
+  def test_new_isolated_subcontext_does_not_inherit_non_static_registers
+    registers = {
+      my_register: :my_value
+    }
+    super_context = Context.new({}, {}, registers)
+    subcontext = super_context.new_isolated_subcontext
+    assert_nil subcontext.registers[:my_register]
+  end
+
+  def test_new_isolated_subcontext_inherits_static_registers
+    super_context = Context.build(static_registers: { my_register: :my_value })
+    subcontext = super_context.new_isolated_subcontext
+    assert_equal :my_value, subcontext.static_registers[:my_register]
+  end
+
+  def test_new_isolated_subcontext_inherits_filters
+    my_filter = Module.new do
+      def my_filter(*)
+        'my filter result'
+      end
+    end
+
+    super_context = Context.new
+    super_context.add_filters([my_filter])
+    subcontext = super_context.new_isolated_subcontext
+    template = Template.parse('{{ 123 | my_filter }}')
+    assert_equal 'my filter result', template.render(subcontext)
+  end
+
+  private
+
+  def assert_no_object_allocations
+    unless RUBY_ENGINE == 'ruby'
+      skip "stackprof needed to count object allocations"
+    end
+    require 'stackprof'
+
+    profile = StackProf.run(mode: :object) do
+      yield
+    end
+    assert_equal 0, profile[:samples]
+  end
 end # ContextTest

test/unit/lexer_unit_test.rb

@@ -19,7 +19,7 @@ class LexerUnitTest < Minitest::Test
   end
 
   def test_comparison
-    tokens = Lexer.new('== <> contains').tokenize
+    tokens = Lexer.new('== <> contains ').tokenize
     assert_equal [[:comparison, '=='], [:comparison, '<>'], [:comparison, 'contains'], [:end_of_string]], tokens
   end
 

test/unit/partial_cache_unit_test.rb

@@ -0,0 +1,91 @@
+require 'test_helper'
+
+class PartialCacheUnitTest < Minitest::Test
+  def test_uses_the_file_system_register_if_present
+    context = Liquid::Context.build(
+      registers: {
+        file_system: StubFileSystem.new('my_partial' => 'my partial body')
+      }
+    )
+
+    partial = Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new
+    )
+
+    assert_equal 'my partial body', partial.render
+  end
+
+  def test_reads_from_the_file_system_only_once_per_file
+    file_system = StubFileSystem.new('my_partial' => 'some partial body')
+    context = Liquid::Context.build(
+      registers: { file_system: file_system }
+    )
+
+    2.times do
+      Liquid::PartialCache.load(
+        'my_partial',
+        context: context,
+        parse_context: Liquid::ParseContext.new
+      )
+    end
+
+    assert_equal 1, file_system.file_read_count
+  end
+
+  def test_cache_state_is_stored_per_context
+    parse_context = Liquid::ParseContext.new
+    shared_file_system = StubFileSystem.new(
+      'my_partial' => 'my shared value'
+    )
+    context_one = Liquid::Context.build(
+      registers: {
+        file_system: shared_file_system
+      }
+    )
+    context_two = Liquid::Context.build(
+      registers: {
+        file_system: shared_file_system
+      }
+    )
+
+    2.times do
+      Liquid::PartialCache.load(
+        'my_partial',
+        context: context_one,
+        parse_context: parse_context
+      )
+    end
+
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context_two,
+      parse_context: parse_context
+    )
+
+    assert_equal 2, shared_file_system.file_read_count
+  end
+
+  def test_cache_is_not_broken_when_a_different_parse_context_is_used
+    file_system = StubFileSystem.new('my_partial' => 'some partial body')
+    context = Liquid::Context.build(
+      registers: { file_system: file_system }
+    )
+
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new(my_key: 'value one')
+    )
+    Liquid::PartialCache.load(
+      'my_partial',
+      context: context,
+      parse_context: Liquid::ParseContext.new(my_key: 'value two')
+    )
+
+    # Technically what we care about is that the file was parsed twice,
+    # but measuring file reads is an OK proxy for this.
+    assert_equal 1, file_system.file_read_count
+  end
+end

test/unit/strainer_unit_test.rb

@@ -145,4 +145,20 @@ class StrainerUnitTest < Minitest::Test
     Strainer.global_filter(LateAddedFilter)
     assert_equal 'filtered', Strainer.create(nil).invoke('late_added_filter', 'input')
   end
+
+  def test_add_filter_does_not_include_already_included_module
+    mod = Module.new do
+      class << self
+        attr_accessor :include_count
+        def included(mod)
+          self.include_count += 1
+        end
+      end
+      self.include_count = 0
+    end
+    strainer = Context.new.strainer
+    strainer.class.add_filter(mod)
+    strainer.class.add_filter(mod)
+    assert_equal 1, mod.include_count
+  end
 end # StrainerTest

test/unit/tag_unit_test.rb

@@ -18,4 +18,42 @@ class TagUnitTest < Minitest::Test
     tag = Tag.parse("some_tag", "", Tokenizer.new(""), ParseContext.new)
     assert_equal 'some_tag', tag.tag_name
   end
+
+  def test_custom_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
+    klass1 = Class.new(Tag) do
+      def render(*)
+        'hello'
+      end
+    end
+
+    with_custom_tag('blabla', klass1) do
+      template = Liquid::Template.parse("{% blabla %}")
+
+      assert_equal 'hello', template.render
+
+      buf = ''
+      output = template.render({}, output: buf)
+      assert_equal 'hello', output
+      assert_equal 'hello', buf
+      assert_equal buf.object_id, output.object_id
+    end
+
+    klass2 = Class.new(klass1) do
+      def render(*)
+        'foo' + super + 'bar'
+      end
+    end
+
+    with_custom_tag('blabla', klass2) do
+      template = Liquid::Template.parse("{% blabla %}")
+
+      assert_equal 'foohellobar', template.render
+
+      buf = ''
+      output = template.render({}, output: buf)
+      assert_equal 'foohellobar', output
+      assert_equal 'foohellobar', buf
+      assert_equal buf.object_id, output.object_id
+    end
+  end
 end