Add support for iterating ranges with float boundaries.

The meaning I gave is to start at the lower bound and step by one. This has the
advantage of having (n..m) and ((n.to_f)..(m.to_f)) behave the same. Another
thing we could do that have this same property is to cast bounds to integer.
This would do the right thing if there is a floating point rounding error, but I
feel it is more surprising for cases such as (1.5..8).

Note that it is not possible to create ranges with floating point boundaries
directly in Liquid at the moment. However, since there is no distinction between
Ruby and Liquid ranges, a drop can introduce such a value by returning it.

.github/probots.yml

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

.gitignore

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

.rubocop.yml

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

.rubocop_todo.yml

@@ -1,101 +1,72 @@
-# This configuration was generated by
+# This configuration was generated by `rubocop --auto-gen-config`
-# `rubocop --auto-gen-config`
+# on 2015-06-08 18:16:16 +0000 using RuboCop version 0.32.0.
-# on 2019-09-11 06:34:25 +1000 using RuboCop version 0.74.0.
 # The point is for the user to remove these configuration records
 # one by one as the offenses are removed from the code base.
 # Note that changes in the inspected code, or installation of new
 # versions of RuboCop, may require this file to be generated again.
 
-# Offense count: 2
+# Offense count: 5
-Lint/AmbiguousOperator:
+Lint/NestedMethodDefinition:
-  Exclude:
+  Enabled: false
-    - 'test/unit/condition_unit_test.rb'
 
-# Offense count: 21
+# Offense count: 53
-# Configuration parameters: AllowSafeAssignment.
+Metrics/AbcSize:
-Lint/AssignmentInCondition:
+  Max: 58
-  Exclude:
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/lexer.rb'
-    - 'lib/liquid/standardfilters.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/tags/raw.rb'
-    - 'lib/liquid/variable.rb'
-    - 'performance/profile.rb'
-    - 'test/test_helper.rb'
-    - 'test/unit/tokenizer_unit_test.rb'
 
-# Offense count: 2
+# Offense count: 12
-# Cop supports --auto-correct.
+Metrics/CyclomaticComplexity:
-# Configuration parameters: EnforcedStyle.
+  Max: 15
-# SupportedStyles: runtime_error, standard_error
-Lint/InheritException:
-  Exclude:
-    - 'lib/liquid/interrupts.rb'
 
-# Offense count: 2
+# Offense count: 553
-Lint/UselessAssignment:
+# Configuration parameters: AllowURI, URISchemes.
-  Exclude:
-    - 'performance/shopify/database.rb'
-
-# Offense count: 1
-# Configuration parameters: CheckForMethodsWithNoSideEffects.
-Lint/Void:
-  Exclude:
-    - 'lib/liquid/parse_context.rb'
-
-# Offense count: 98
-# Cop supports --auto-correct.
-# Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
-# URISchemes: http, https
 Metrics/LineLength:
   Max: 294
 
-# Offense count: 44
+# Offense count: 77
-Naming/ConstantName:
+# Configuration parameters: CountComments.
-  Exclude:
+Metrics/MethodLength:
-    - 'lib/liquid.rb'
+  Max: 46
-    - 'lib/liquid/block_body.rb'
-    - 'lib/liquid/tags/assign.rb'
-    - 'lib/liquid/tags/capture.rb'
-    - 'lib/liquid/tags/case.rb'
-    - 'lib/liquid/tags/cycle.rb'
-    - 'lib/liquid/tags/for.rb'
-    - 'lib/liquid/tags/if.rb'
-    - 'lib/liquid/tags/include.rb'
-    - 'lib/liquid/tags/raw.rb'
-    - 'lib/liquid/tags/table_row.rb'
-    - 'lib/liquid/variable.rb'
-    - 'performance/shopify/comment_form.rb'
-    - 'performance/shopify/paginate.rb'
-    - 'test/integration/tags/include_tag_test.rb'
 
-# Offense count: 5
+# Offense count: 6
-Style/ClassVars:
+Metrics/PerceivedComplexity:
-  Exclude:
+  Max: 13
-    - 'lib/liquid/condition.rb'
-    - 'lib/liquid/strainer.rb'
-    - 'lib/liquid/template.rb'
 
 # Offense count: 1
-# Configuration parameters: AllowCoercion.
+Style/AccessorMethodName:
-Style/DateTime:
-  Exclude:
-    - 'test/unit/context_unit_test.rb'
-
-# Offense count: 119
-# Cop supports --auto-correct.
-# Configuration parameters: EnforcedStyle.
-# SupportedStyles: always, never
-Style/FrozenStringLiteralComment:
   Enabled: false
 
-# Offense count: 9
+# Offense count: 1
+# Cop supports --auto-correct.
+Style/ClosingParenthesisIndentation:
+  Enabled: false
+
+# Offense count: 3
+# Configuration parameters: MinBodyLength.
+Style/GuardClause:
+  Enabled: false
+
+# Offense count: 4
+# Configuration parameters: EnforcedStyle, SupportedStyles.
+Style/MethodName:
+  Enabled: false
+
+# Offense count: 1
+Style/MultilineBlockChain:
+  Enabled: false
+
+# Offense count: 2
+# Configuration parameters: EnforcedStyle, MinBodyLength, SupportedStyles.
+Style/Next:
+  Enabled: false
+
+# Offense count: 7
 # Cop supports --auto-correct.
 # Configuration parameters: AllowAsExpressionSeparator.
 Style/Semicolon:
-  Exclude:
+  Enabled: false
-    - 'test/integration/error_handling_test.rb'
+
-    - 'test/integration/template_test.rb'
+# Offense count: 1
-    - 'test/unit/context_unit_test.rb'
+# Cop supports --auto-correct.
+# Configuration parameters: MaxLineLength.
+Style/WhileUntilModifier:
+  Enabled: false

.travis.yml

@@ -1,30 +1,29 @@
 language: ruby
-cache: bundler
 
 rvm:
-  - 2.4
+  - 2.1
-  - 2.5
+  - 2.2
-  - &latest_ruby 2.6
+  - 2.3.3
-  - 2.7
   - ruby-head
   - jruby-head
-  - truffleruby
+#  - rbx-2
+
+sudo: false
+
+addons:
+  apt:
+    packages:
+    - libgmp3-dev
 
 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
 
-branches:
+install:
-  only:
+  - gem install rainbow -v 2.2.1
-    - master
+  - bundle install
-    - gh-pages
+
-    - /.*-stable/
+script: "bundle exec rake"
 
 notifications:
   disable: true

Gemfile

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

History.md

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

README.md

@@ -42,8 +42,6 @@ Liquid is a template engine which was written with very specific requirements:
 
 ## How to use Liquid
 
-Install Liquid by adding `gem 'liquid'` to your gemfile.
-
 Liquid supports a very simple API based around the Liquid::Template class.
 For standard use you can just pass it the content of a file and call render with a parameters hash.
 
@@ -106,9 +104,3 @@ template = Liquid::Template.parse("{{x}} {{y}}")
 template.render!({ 'x' => 1}, { strict_variables: true })
 #=> Liquid::UndefinedVariable: Liquid error: undefined variable y
 ```
-
-### Usage tracking
-
-To help track usages of a feature or code path in production, we have released opt-in usage tracking. To enable this, we provide an empty `Liquid:: Usage.increment` method which you can customize to your needs. The feature is well suited to https://github.com/Shopify/statsd-instrument. However, the choice of implementation is up to you.
-
-Once you have enabled usage tracking, we recommend reporting any events through Github Issues that your system may be logging. It is highly likely this event has been added to consider deprecating or improving code specific to this event, so please raise any concerns.

Rakefile

@@ -1,31 +1,29 @@
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
 require "liquid/version"
 
-task(default: [:test, :rubocop])
+task default: [:rubocop, :test]
 
-desc('run test suite with default parser')
+desc 'run test suite with default parser'
 Rake::TestTask.new(:base_test) do |t|
   t.libs << '.' << 'lib' << 'test'
   t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
   t.verbose = false
 end
 
-desc('run test suite with warn error mode')
+desc 'run test suite with warn error mode'
 task :warn_test do
   ENV['LIQUID_PARSER_MODE'] = 'warn'
   Rake::Task['base_test'].invoke
 end
 
 task :rubocop do
-  if RUBY_ENGINE == 'ruby'
+  require 'rubocop/rake_task'
-    require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
-    RuboCop::RakeTask.new
-  end
 end
 
-desc('runs test suite with both strict and lax parsers')
+desc 'runs test suite with both strict and lax parsers'
 task :test do
   ENV['LIQUID_PARSER_MODE'] = 'lax'
   Rake::Task['base_test'].invoke
@@ -34,8 +32,8 @@ task :test do
   Rake::Task['base_test'].reenable
   Rake::Task['base_test'].invoke
 
-  if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
+  if RUBY_ENGINE == 'ruby'
-    ENV['LIQUID_C'] = '1'
+    ENV['LIQUID-C'] = '1'
 
     ENV['LIQUID_PARSER_MODE'] = 'lax'
     Rake::Task['base_test'].reenable
@@ -47,7 +45,7 @@ task :test do
   end
 end
 
-task(gem: :build)
+task gem: :build
 task :build do
   system "gem build liquid.gemspec"
 end
@@ -87,14 +85,7 @@ namespace :profile do
   end
 end
 
-namespace :memory_profile do
+desc "Run example"
-  desc "Run memory profiler"
-  task :run do
-    ruby "./performance/memory_profile.rb"
-  end
-end
-
-desc("Run example")
 task :example do
   ruby "-w -d -Ilib example/server/server.rb"
 end

circle.yml

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

example/server/example_servlet.rb

@@ -1,6 +1,6 @@
 module ProductsFilter
   def price(integer)
-    format("$%.2d USD", integer / 100.0)
+    sprintf("$%.2d USD", integer / 100.0)
   end
 
   def prettyprint(text)

example/server/liquid_servlet.rb

@@ -9,12 +9,12 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
 
   private
 
-  def handle(_type, req, res)
+  def handle(type, req, res)
     @request = req
     @response = res
 
     @request.path_info =~ /(\w+)\z/
-    @action = Regexp.last_match(1) || 'index'
+    @action = $1 || 'index'
     @assigns = send(@action) if respond_to?(@action)
 
     @response['Content-Type'] = "text/html"

example/server/server.rb

@@ -8,5 +8,5 @@ require_relative 'example_servlet'
 # Setup webrick
 server = WEBrick::HTTPServer.new(Port: ARGV[1] || 3000)
 server.mount('/', Servlet)
-trap("INT") { server.shutdown }
+trap("INT"){ server.shutdown }
 server.start

lib/liquid.rb

@@ -45,7 +45,6 @@ module Liquid
 end
 
 require "liquid/version"
-require 'liquid/parse_tree_visitor'
 require 'liquid/lexer'
 require 'liquid/parser'
 require 'liquid/i18n'
@@ -74,8 +73,6 @@ 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
 #

lib/liquid/block.rb

@@ -13,7 +13,6 @@ module Liquid
       end
     end
 
-    # For backwards compatibility
     def render(context)
       @body.render(context)
     end
@@ -27,16 +26,16 @@ module Liquid
     end
 
     def unknown_tag(tag, _params, _tokens)
-      if tag == 'else'.freeze
+      case tag
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else".freeze,
+      when 'else'.freeze
-          block_name: block_name)
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_else".freeze,
-      elsif tag.start_with?('end'.freeze)
+          block_name: block_name))
-        raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
+      when 'end'.freeze
-          tag: tag,
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
           block_name: block_name,
-          block_delimiter: block_delimiter)
+          block_delimiter: block_delimiter))
       else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag)
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
       end
     end
 
@@ -61,7 +60,7 @@ module Liquid
 
           return false if end_tag_name == block_delimiter
           unless end_tag_name
-            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)
+            raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
           end
 
           # this tag is not registered with the system

lib/liquid/block_body.rb

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

lib/liquid/condition.rb

@@ -11,32 +11,32 @@ module Liquid
       '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
       '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
       '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<'.freeze => :<,
+      '<'.freeze  => :<,
-      '>'.freeze => :>,
+      '>'.freeze  => :>,
       '>='.freeze => :>=,
       '<='.freeze => :<=,
-      'contains'.freeze => lambda do |_cond, left, right|
+      'contains'.freeze => lambda do |cond, left, right|
         if left && right && left.respond_to?(:include?)
           right = right.to_s if left.is_a?(String)
           left.include?(right)
         else
           false
         end
-      end,
+      end
     }
 
     def self.operators
       @@operators
     end
 
-    attr_reader :attachment, :child_condition
+    attr_reader :attachment
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
       @left = left
       @operator = operator
       @right = right
-      @child_relation = nil
+      @child_relation  = nil
       @child_condition = nil
     end
 
@@ -83,7 +83,7 @@ module Liquid
 
     protected
 
-    attr_reader :child_relation
+    attr_reader :child_relation, :child_condition
 
     private
 
@@ -116,7 +116,7 @@ module Liquid
       left = context.evaluate(left)
       right = context.evaluate(right)
 
-      operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
+      operation = self.class.operators[op] || raise(Liquid::ArgumentError.new("Unknown operator #{op}"))
 
       if operation.respond_to?(:call)
         operation.call(self, left, right)
@@ -124,19 +124,10 @@ module Liquid
         begin
           left.send(operation, right)
         rescue ::ArgumentError => e
-          raise Liquid::ArgumentError, e.message
+          raise Liquid::ArgumentError.new(e.message)
         end
       end
     end
-
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
-      def children
-        [
-          @node.left, @node.right,
-          @node.child_condition, @node.attachment
-        ].compact
-      end
-    end
   end
 
   class ElseCondition < Condition

lib/liquid/context.rb

@@ -12,35 +12,30 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
     attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
-    # rubocop:disable Metrics/ParameterLists
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_registers: {}, static_environments: {})
+      @environments     = [environments].flatten
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_registers, static_environments)
+      @scopes           = [(outer_scope || {})]
-    end
+      @registers        = registers
+      @errors           = []
+      @partial          = false
+      @strict_variables = false
+      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
+      squash_instance_assigns_with_environments
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_registers = {}, static_environments = {})
+      @this_stack_used = false
-      @environments        = environments.is_a?(Array) ? environments : [environments]
-      @static_environments = [static_environments].flat_map(&:freeze).freeze
-      @scopes              = [(outer_scope || {})]
-      @registers           = registers
-      @static_registers    = static_registers.freeze
-      @errors              = []
-      @partial             = false
-      @strict_variables    = false
-      @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
-      @base_scope_depth    = 0
-      @interrupts          = []
-      @filters             = []
-      @global_filter       = nil
 
       self.exception_renderer = Template.default_exception_renderer
       if rethrow_errors
-        self.exception_renderer = ->(_e) { raise }
+        self.exception_renderer = ->(e) { raise }
       end
+
+      @interrupts = []
+      @filters = []
+      @global_filter = nil
     end
-    # rubocop:enable Metrics/ParameterLists
 
     def warnings
       @warnings ||= []
@@ -94,7 +89,7 @@ module Liquid
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope = {})
       @scopes.unshift(new_scope)
-      check_overflow
+      raise StackLevelError, "Nesting too deep".freeze if @scopes.length > Block::MAX_DEPTH
     end
 
     # Merge a hash of variables in the current local scope
@@ -116,30 +111,19 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope = {})
+    def stack(new_scope = nil)
-      push(new_scope)
+      old_stack_used = @this_stack_used
+      if new_scope
+        push(new_scope)
+        @this_stack_used = true
+      else
+        @this_stack_used = false
+      end
+
       yield
     ensure
-      pop
+      pop if @this_stack_used
-    end
+      @this_stack_used = old_stack_used
-
-    # 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
@@ -148,6 +132,10 @@ module Liquid
 
     # Only allow String, Numeric, Hash, Array, Proc, Boolean or <tt>Liquid::Drop</tt>
     def []=(key, value)
+      unless @this_stack_used
+        @this_stack_used = true
+        push({})
+      end
       @scopes[0][key] = value
     end
 
@@ -176,13 +164,23 @@ module Liquid
       # 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 = if index
+      variable = nil
-        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
+
-      else
+      if scope.nil?
-        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
+        @environments.each do |e|
+          variable = lookup_and_evaluate(e, key, raise_on_not_found: raise_on_not_found)
+          unless variable.nil?
+            scope = e
+            break
+          end
+        end
       end
 
+      scope ||= @environments.last || @scopes.last
+      variable ||= lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
+
       variable = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
@@ -197,49 +195,30 @@ module Liquid
       value = obj[key]
 
       if value.is_a?(Proc) && obj.respond_to?(:[]=)
-        obj[key] = value.arity == 0 ? value.call : value.call(self)
+        obj[key] = (value.arity == 0) ? value.call : value.call(self)
       else
         value
       end
     end
 
-    protected
-
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
-
     private
 
-    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'
     rescue Liquid::InternalError => exc
       exc
     end
+
+    def squash_instance_assigns_with_environments
+      @scopes.last.each_key do |k|
+        @environments.each do |env|
+          if env.key?(k)
+            scopes.last[k] = lookup_and_evaluate(env, k)
+            break
+          end
+        end
+      end
+    end # squash_instance_assigns_with_environments
   end # Context
 end # Liquid

lib/liquid/document.rb

@@ -7,7 +7,7 @@ module Liquid
     end
 
     def parse(tokens, parse_context)
-      super do |end_tag_name, _end_tag_params|
+      super do |end_tag_name, end_tag_params|
         unknown_tag(end_tag_name, parse_context) if end_tag_name
       end
     rescue SyntaxError => e
@@ -18,9 +18,9 @@ module Liquid
     def unknown_tag(tag, parse_context)
       case tag
       when 'else'.freeze, 'end'.freeze
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag)
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag))
       else
-        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag)
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag))
       end
     end
   end

lib/liquid/drop.rb

@@ -25,7 +25,7 @@ module Liquid
 
     # Catch all for the method
     def liquid_method_missing(method)
-      return nil unless @context&.strict_variables
+      return nil unless @context && @context.strict_variables
       raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 

lib/liquid/errors.rb

@@ -21,10 +21,10 @@ module Liquid
 
     def message_prefix
       str = ""
-      str << if is_a?(SyntaxError)
+      if is_a?(SyntaxError)
-        "Liquid syntax error"
+        str << "Liquid syntax error"
       else
-        "Liquid error"
+        str << "Liquid error"
       end
 
       if line_number

lib/liquid/expression.rb

@@ -15,31 +15,27 @@ module Liquid
 
     LITERALS = {
       nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
-      'true'.freeze => true,
+      'true'.freeze  => true,
       '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 SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
+        when /\A'(.*)'\z/m # Single quoted strings
-          Regexp.last_match(1)
+          $1
-        when INTEGERS_REGEX
+        when /\A"(.*)"\z/m # Double quoted strings
-          Regexp.last_match(1).to_i
+          $1
-        when RANGES_REGEX
+        when /\A(-?\d+)\z/ # Integer and floats
-          RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
+          $1.to_i
-        when FLOATS_REGEX
+        when /\A\((\S+)\.\.(\S+)\)\z/ # Ranges
-          Regexp.last_match(1).to_f
+          RangeLookup.parse($1, $2)
+        when /\A(-?\d[\d\.]+)\z/ # Floats
+          $1.to_f
         else
           VariableLookup.parse(markup)
         end

lib/liquid/extensions.rb

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

lib/liquid/file_system.rb

@@ -57,7 +57,7 @@ module Liquid
     end
 
     def full_path(template_path)
-      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ %r{\A[^./][a-zA-Z0-9_/]+\z}
+      raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ /\A[^.\/][a-zA-Z0-9_\/]+\z/
 
       full_path = if template_path.include?('/'.freeze)
         File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))

lib/liquid/i18n.rb

@@ -26,13 +26,13 @@ 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[Regexp.last_match(1).to_sym]).to_s
+        "#{vars[$1.to_sym]}"
       end
     end
 
     def deep_fetch_translation(name)
       name.split('.'.freeze).reduce(locale) do |level, cur|
-        level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
+        level[cur] or raise TranslationError, "Translation for #{name} does not exist in locale #{path}"
       end
     end
   end

lib/liquid/lexer.rb

@@ -11,15 +11,14 @@ module Liquid
       '('.freeze => :open_round,
       ')'.freeze => :close_round,
       '?'.freeze => :question,
-      '-'.freeze => :dash,
+      '-'.freeze => :dash
-    }.freeze
+    }
     IDENTIFIER = /[a-zA-Z_][\w-]*\??/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
     NUMBER_LITERAL = /-?\d+(\.\d+)?/
     DOTDOT = /\.\./
     COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
-    WHITESPACE_OR_NOTHING = /\s*/
 
     def initialize(input)
       @ss = StringScanner.new(input)
@@ -29,14 +28,15 @@ module Liquid
       @output = []
 
       until @ss.eos?
-        @ss.skip(WHITESPACE_OR_NOTHING)
+        @ss.skip(/\s*/)
         break if @ss.eos?
-        tok = if t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        tok = case
-        elsif t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
-        elsif t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        when t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
-        elsif t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        when t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
-        elsif t = @ss.scan(IDENTIFIER) then [:id, t]
+        when t = @ss.scan(NUMBER_LITERAL) then [:number, t]
-        elsif t = @ss.scan(DOTDOT) then [:dotdot, t]
+        when t = @ss.scan(IDENTIFIER) then [:id, t]
+        when t = @ss.scan(DOTDOT) then [:dotdot, t]
         else
           c = @ss.getch
           if s = SPECIALS[c]

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: "'%{tag}' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
+      invalid_delimiter: "'end' is not a valid delimiter for %{block_name} tags. use %{block_delimiter}"
       unexpected_else: "%{block_name} tag does not expect 'else' tag"
       unexpected_outer_tag: "Unexpected outer '%{tag}' tag"
       tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
@@ -22,6 +22,5 @@
       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

@@ -28,7 +28,7 @@ module Liquid
         if dont_pass == true
           { locale: locale }
         elsif dont_pass.is_a?(Array)
-          @template_options.reject { |k, _v| dont_pass.include?(k) }
+          @template_options.reject { |k, v| dont_pass.include?(k) }
         else
           @template_options
         end

lib/liquid/parse_tree_visitor.rb

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

lib/liquid/parser.rb

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

lib/liquid/partial_cache.rb

@@ -1,18 +0,0 @@
-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(context, output, node)
+    def render_node_with_profiling(node, context)
       Profiler.profile_node_render(node) do
-        render_node_without_profiling(context, output, node)
+        render_node_without_profiling(node, context)
       end
     end
 
@@ -11,13 +11,13 @@ module Liquid
   end
 
   class Include < Tag
-    def render_to_output_buffer_with_profiling(context, output)
+    def render_with_profiling(context)
       Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_to_output_buffer_without_profiling(context, output)
+        render_without_profiling(context)
       end
     end
 
-    alias_method :render_to_output_buffer_without_profiling, :render_to_output_buffer
+    alias_method :render_without_profiling, :render
-    alias_method :render_to_output_buffer, :render_to_output_buffer_with_profiling
+    alias_method :render, :render_with_profiling
   end
 end

lib/liquid/standardfilters.rb

@@ -8,15 +8,9 @@ module Liquid
       '>'.freeze => '>'.freeze,
       '<'.freeze => '&lt;'.freeze,
       '"'.freeze => '&quot;'.freeze,
-      "'".freeze => '&#39;'.freeze,
+      "'".freeze => '&#39;'.freeze
-    }.freeze
+    }
     HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
-    STRIP_HTML_BLOCKS = Regexp.union(
-      %r{<script.*?</script>}m,
-      /<!--.*?-->/m,
-      %r{<style.*?</style>}m
-    )
-    STRIP_HTML_TAGS = /<.*?>/m
 
     # Return the size of an array or of an string
     def size(input)
@@ -52,12 +46,7 @@ module Liquid
     end
 
     def url_decode(input)
-      return if input.nil?
+      CGI.unescape(input.to_s) unless 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)
@@ -79,7 +68,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].concat(truncate_string_str) : input_str
+      input_str.length > length ? input_str[0...l] + truncate_string_str : input_str
     end
 
     def truncatewords(input, words = 15, truncate_string = "...".freeze)
@@ -88,7 +77,7 @@ module Liquid
       words = Utils.to_integer(words)
       l = words - 1
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(" ".freeze).concat(truncate_string.to_s) : input
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze) + truncate_string.to_s : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -114,9 +103,7 @@ module Liquid
 
     def strip_html(input)
       empty = ''.freeze
-      result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
+      input.to_s.gsub(/<script.*?<\/script>/m, empty).gsub(/<!--.*?-->/m, empty).gsub(/<style.*?<\/style>/m, empty).gsub(/<.*?>/m, empty)
-      result.gsub!(STRIP_HTML_TAGS, empty)
-      result
     end
 
     # Remove all newlines from the string
@@ -133,18 +120,19 @@ 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|
-          nil_safe_compare(a, b)
+          a = a[property]
-        end
+          b = b[property]
-      elsif ary.all? { |el| el.respond_to?(:[]) }
+          if a && b
-        begin
+            a <=> b
-          ary.sort { |a, b| nil_safe_compare(a[property], b[property]) }
+          else
-        rescue TypeError
+            a ? -1 : 1
-          raise_property_error(property)
+          end
         end
       end
     end
@@ -154,40 +142,12 @@ module Liquid
     def sort_natural(input, property = nil)
       ary = InputIterator.new(input)
 
-      return [] if ary.empty?
-
       if property.nil?
-        ary.sort do |a, b|
+        ary.sort { |a, b| a.casecmp(b) }
-          nil_safe_casecmp(a, b)
+      elsif ary.empty? # The next two cases assume a non-empty array.
-        end
-      elsif ary.all? { |el| el.respond_to?(:[]) }
-        begin
-          ary.sort { |a, b| nil_safe_casecmp(a[property], b[property]) }
-        rescue TypeError
-          raise_property_error(property)
-        end
-      end
-    end
-
-    # Filter the elements of an array to those with a certain property value.
-    # By default the target is any truthy value.
-    def where(input, property, target_value = nil)
-      ary = InputIterator.new(input)
-
-      if ary.empty?
         []
-      elsif ary.first.respond_to?(:[]) && target_value.nil?
+      elsif ary.first.respond_to?(:[]) && !ary.first[property].nil?
-        begin
+        ary.sort { |a, b| a[property].casecmp(b[property]) }
-          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
 
@@ -201,11 +161,7 @@ module Liquid
       elsif ary.empty? # The next two cases assume a non-empty array.
         []
       elsif ary.first.respond_to?(:[])
-        begin
+        ary.uniq{ |a| a[property] }
-          ary.uniq { |a| a[property] }
-        rescue TypeError
-          raise_property_error(property)
-        end
       end
     end
 
@@ -227,8 +183,6 @@ module Liquid
           r.is_a?(Proc) ? r.call : r
         end
       end
-    rescue TypeError
-      raise_property_error(property)
     end
 
     # Remove nils within an array
@@ -241,11 +195,7 @@ module Liquid
       elsif ary.empty? # The next two cases assume a non-empty array.
         []
       elsif ary.first.respond_to?(:[])
-        begin
+        ary.reject{ |a| a[property].nil? }
-          ary.reject { |a| a[property].nil? }
-        rescue TypeError
-          raise_property_error(property)
-        end
       end
     end
 
@@ -276,7 +226,7 @@ module Liquid
 
     def concat(input, array)
       unless array.respond_to?(:to_ary)
-        raise ArgumentError, "concat filter requires an array argument"
+        raise ArgumentError.new("concat filter requires an array argument")
       end
       InputIterator.new(input).concat(array)
     end
@@ -403,25 +353,8 @@ 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?
-        Usage.increment("default_filter_received_false_value") if input == false # See https://github.com/Shopify/liquid/issues/1127
         default_value
       else
         input
@@ -430,31 +363,11 @@ module Liquid
 
     private
 
-    def raise_property_error(property)
-      raise Liquid::ArgumentError, "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
 

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 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(', ')}"
@@ -54,7 +54,7 @@ module Liquid
     def invoke(method, *args)
       if self.class.invokable?(method)
         send(method, *args)
-      elsif @context&.strict_filters
+      elsif @context && @context.strict_filters
         raise Liquid::UndefinedFilter, "undefined filter #{method}"
       else
         args.first

lib/liquid/tag.rb

@@ -5,8 +5,8 @@ module Liquid
     include ParserSwitching
 
     class << self
-      def parse(tag_name, markup, tokenizer, parse_context)
+      def parse(tag_name, markup, tokenizer, options)
-        tag = new(tag_name, markup, parse_context)
+        tag = new(tag_name, markup, options)
         tag.parse(tokenizer)
         tag
       end
@@ -36,14 +36,6 @@ 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,27 +10,21 @@ 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 = Regexp.last_match(1)
+        @to = $1
-        @from = Variable.new(Regexp.last_match(2), options)
+        @from = Variable.new($2, options)
       else
-        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
+        raise SyntaxError.new options[:locale].t("errors.syntax.assign".freeze)
       end
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       val = @from.render(context)
       context.scopes.last[@to] = val
       context.resource_limits.assign_score += assign_score_of(val)
-      output
+      ''.freeze
     end
 
     def blank?
@@ -41,7 +35,7 @@ module Liquid
 
     def assign_score_of(val)
       if val.instance_of?(String)
-        val.bytesize
+        val.length
       elsif val.instance_of?(Array) || val.instance_of?(Hash)
         sum = 1
         # Uses #each to avoid extra allocations.
@@ -51,12 +45,6 @@ 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

@@ -16,18 +16,17 @@ module Liquid
     def initialize(tag_name, markup, options)
       super
       if markup =~ Syntax
-        @to = Regexp.last_match(1)
+        @to = $1
       else
-        raise SyntaxError, options[:locale].t("errors.syntax.capture")
+        raise SyntaxError.new(options[:locale].t("errors.syntax.capture"))
       end
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
-      previous_output_size = output.bytesize
+      output = super
-      super
       context.scopes.last[@to] = output
-      context.resource_limits.assign_score += (output.bytesize - previous_output_size)
+      context.resource_limits.assign_score += output.length
-      output
+      ''.freeze
     end
 
     def blank?

lib/liquid/tags/case.rb

@@ -3,22 +3,22 @@ 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 = []
 
       if markup =~ Syntax
-        @left = Expression.parse(Regexp.last_match(1))
+        @left = Expression.parse($1)
       else
-        raise SyntaxError, options[:locale].t("errors.syntax.case".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case".freeze))
       end
     end
 
     def parse(tokens)
       body = BlockBody.new
-      body = @blocks.last.attachment while parse_body(body, tokens)
+      while parse_body(body, tokens)
+        body = @blocks.last.attachment
+      end
     end
 
     def nodelist
@@ -36,19 +36,21 @@ module Liquid
       end
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
-      execute_else_block = true
+      context.stack do
+        execute_else_block = true
 
-      @blocks.each do |block|
+        output = ''
-        if block.else?
+        @blocks.each do |block|
-          block.attachment.render_to_output_buffer(context, output) if execute_else_block
+          if block.else?
-        elsif block.evaluate(context)
+            return block.attachment.render(context) if execute_else_block
-          execute_else_block = false
+          elsif block.evaluate(context)
-          block.attachment.render_to_output_buffer(context, output)
+            execute_else_block = false
+            output << block.attachment.render(context)
+          end
         end
+        output
       end
-
-      output
     end
 
     private
@@ -58,12 +60,12 @@ module Liquid
 
       while markup
         unless markup =~ WhenSyntax
-          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when".freeze)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_when".freeze))
         end
 
-        markup = Regexp.last_match(2)
+        markup = $2
 
-        block = Condition.new(@left, '=='.freeze, Expression.parse(Regexp.last_match(1)))
+        block = Condition.new(@left, '=='.freeze, Expression.parse($1))
         block.attach(body)
         @blocks << block
       end
@@ -71,19 +73,13 @@ module Liquid
 
     def record_else_condition(markup)
       unless markup.strip.empty?
-        raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.case_invalid_else".freeze))
       end
 
       block = ElseCondition.new
       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_to_output_buffer(_context, output)
+    def render(_context)
-      output
+      ''.freeze
     end
 
     def unknown_tag(_tag, _markup, _tokens)

lib/liquid/tags/cycle.rb

@@ -15,43 +15,32 @@ module Liquid
     SimpleSyntax = /\A#{QuotedFragment}+/o
     NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
 
-    attr_reader :variables
-
     def initialize(tag_name, markup, options)
       super
       case markup
       when NamedSyntax
-        @variables = variables_from_string(Regexp.last_match(2))
+        @variables = variables_from_string($2)
-        @name = Expression.parse(Regexp.last_match(1))
+        @name = Expression.parse($1)
       when SimpleSyntax
         @variables = variables_from_string(markup)
         @name = @variables.to_s
       else
-        raise SyntaxError, options[:locale].t("errors.syntax.cycle".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.cycle".freeze))
       end
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
-      context.registers[:cycle] ||= {}
+      context.registers[:cycle] ||= Hash.new(0)
 
-      key = context.evaluate(@name)
+      context.stack do
-      iteration = context.registers[:cycle][key].to_i
+        key = context.evaluate(@name)
-
+        iteration = context.registers[:cycle][key]
-      val = context.evaluate(@variables[iteration])
+        result = context.evaluate(@variables[iteration])
-
+        iteration += 1
-      if val.is_a?(Array)
+        iteration  = 0 if iteration >= @variables.size
-        val = val.join
+        context.registers[:cycle][key] = iteration
-      elsif !val.is_a?(String)
+        result
-        val = val.to_s
       end
-
-      output << val
-
-      iteration += 1
-      iteration  = 0 if iteration >= @variables.size
-      context.registers[:cycle][key] = iteration
-
-      output
     end
 
     private
@@ -59,15 +48,9 @@ module Liquid
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
+        $1 ? 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,12 +23,11 @@ module Liquid
       @variable = markup.strip
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       value = context.environments.first[@variable] ||= 0
       value -= 1
       context.environments.first[@variable] = value
-      output << value.to_s
+      value.to_s
-      output
     end
   end
 

lib/liquid/tags/echo.rb

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

@@ -46,7 +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
+    attr_reader :collection_name
+    attr_reader :variable_name
 
     def initialize(tag_name, markup, options)
       super
@@ -70,39 +71,37 @@ module Liquid
       @else_block = BlockBody.new
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       segment = collection_segment(context)
 
       if segment.empty?
-        render_else(context, output)
+        render_else(context)
       else
-        render_segment(context, output, segment)
+        render_segment(context, segment)
       end
-
-      output
     end
 
     protected
 
     def lax_parse(markup)
       if markup =~ Syntax
-        @variable_name = Regexp.last_match(1)
+        @variable_name = $1
-        collection_name = Regexp.last_match(2)
+        collection_name = $2
-        @reversed = !!Regexp.last_match(3)
+        @reversed = !!$3
         @name = "#{@variable_name}-#{collection_name}"
         @collection_name = Expression.parse(collection_name)
         markup.scan(TagAttributes) do |key, value|
           set_attribute(key, value)
         end
       else
-        raise SyntaxError, options[:locale].t("errors.syntax.for".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.for".freeze))
       end
     end
 
     def strict_parse(markup)
       p = Parser.new(markup)
       @variable_name = p.consume(:id)
-      raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in".freeze) unless p.id?('in'.freeze)
+      raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_in".freeze)) unless p.id?('in'.freeze)
       collection_name = p.expression
       @name = "#{@variable_name}-#{collection_name}"
       @collection_name = Expression.parse(collection_name)
@@ -110,7 +109,7 @@ module Liquid
 
       while p.look(:id) && p.look(:colon, 1)
         unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
-          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute".freeze)
+          raise SyntaxError.new(options[:locale].t("errors.syntax.for_invalid_attribute".freeze))
         end
         p.consume
         set_attribute(attribute, p.expression)
@@ -121,28 +120,19 @@ module Liquid
     private
 
     def collection_segment(context)
-      offsets = context.registers[:for] ||= {}
+      offsets = context.registers[:for] ||= Hash.new(0)
 
       from = if @from == :continue
         offsets[@name].to_i
       else
-        from_value = context.evaluate(@from)
+        context.evaluate(@from).to_i
-        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)
+      collection = collection.step(1).to_a if collection.is_a?(Range)
 
-      limit_value = context.evaluate(@limit)
+      limit = context.evaluate(@limit)
-      to = if limit_value.nil?
+      to = limit ? limit.to_i + from : nil
-        nil
-      else
-        Utils.to_integer(limit_value) + from
-      end
 
       segment = Utils.slice_collection(collection, from, to)
       segment.reverse! if @reversed
@@ -152,10 +142,12 @@ module Liquid
       segment
     end
 
-    def render_segment(context, output, segment)
+    def render_segment(context, segment)
       for_stack = context.registers[:for_stack] ||= []
       length = segment.length
 
+      result = ''
+
       context.stack do
         loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
 
@@ -164,23 +156,24 @@ module Liquid
         begin
           context['forloop'.freeze] = loop_vars
 
-          segment.each do |item|
+          segment.each_with_index do |item, index|
             context[@variable_name] = item
-            @for_block.render_to_output_buffer(context, output)
+            result << @for_block.render(context)
             loop_vars.send(:increment!)
 
             # Handle any interrupts if they exist.
-            next unless context.interrupt?
+            if context.interrupt?
-            interrupt = context.pop_interrupt
+              interrupt = context.pop_interrupt
-            break if interrupt.is_a?(BreakInterrupt)
+              break if interrupt.is_a? BreakInterrupt
-            next if interrupt.is_a?(ContinueInterrupt)
+              next if interrupt.is_a? ContinueInterrupt
+            end
           end
         ensure
           for_stack.pop
         end
       end
 
-      output
+      result
     end
 
     def set_attribute(key, expr)
@@ -196,18 +189,8 @@ module Liquid
       end
     end
 
-    def render_else(context, output)
+    def render_else(context)
-      if @else_block
+      @else_block ? @else_block.render(context) : ''.freeze
-        @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,9 +12,7 @@ module Liquid
   class If < Block
     Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
     ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS = %w(and or).freeze
+    BOOLEAN_OPERATORS = %w(and or)
-
-    attr_reader :blocks
 
     def initialize(tag_name, markup, options)
       super
@@ -22,15 +20,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)
@@ -39,14 +37,15 @@ module Liquid
       end
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
-      @blocks.each do |block|
+      context.stack do
-        if block.evaluate(context)
+        @blocks.each do |block|
-          return block.attachment.render_to_output_buffer(context, output)
+          if block.evaluate(context)
+            return block.attachment.render(context)
+          end
         end
+        ''.freeze
       end
-
-      output
     end
 
     private
@@ -64,17 +63,17 @@ module Liquid
 
     def lax_parse(markup)
       expressions = markup.scan(ExpressionsAndOperators)
-      raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless expressions.pop =~ Syntax
+      raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop =~ Syntax
 
-      condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+      condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
 
       until expressions.empty?
         operator = expressions.pop.to_s.strip
 
-        raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless expressions.pop.to_s =~ Syntax
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless expressions.pop.to_s =~ Syntax
 
-        new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+        new_condition = Condition.new(Expression.parse($1), $2, Expression.parse($3))
-        raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless BOOLEAN_OPERATORS.include?(operator)
+        raise(SyntaxError.new(options[:locale].t("errors.syntax.if".freeze))) unless BOOLEAN_OPERATORS.include?(operator)
         new_condition.send(operator, condition)
         condition = new_condition
       end
@@ -109,12 +108,6 @@ 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,15 +1,16 @@
 module Liquid
   class Ifchanged < Block
-    def render_to_output_buffer(context, output)
+    def render(context)
-      block_output = ''
+      context.stack do
-      super(context, block_output)
+        output = super
 
-      if block_output != context.registers[:ifchanged]
+        if output != context.registers[:ifchanged]
-        context.registers[:ifchanged] = block_output
+          context.registers[:ifchanged] = output
-        output << block_output
+          output
+        else
+          ''.freeze
+        end
       end
-
-      output
     end
   end
 

lib/liquid/tags/include.rb

@@ -16,15 +16,13 @@ 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
 
       if markup =~ Syntax
 
-        template_name = Regexp.last_match(1)
+        template_name = $1
-        variable_name = Regexp.last_match(3)
+        variable_name = $3
 
         @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
         @template_name_expr = Expression.parse(template_name)
@@ -35,23 +33,18 @@ module Liquid
         end
 
       else
-        raise SyntaxError, options[:locale].t("errors.syntax.include".freeze)
+        raise SyntaxError.new(options[:locale].t("errors.syntax.include".freeze))
       end
     end
 
     def parse(_tokens)
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
+      raise ArgumentError.new(options[:locale].t("errors.argument.include")) unless template_name
-
-      partial = PartialCache.load(
-        template_name,
-        context: context,
-        parse_context: parse_context
-      )
 
+      partial = load_cached_partial(template_name, context)
       context_variable_name = template_name.split('/'.freeze).last
 
       variable = if @variable_name_expr
@@ -71,33 +64,48 @@ module Liquid
           end
 
           if variable.is_a?(Array)
-            variable.each do |var|
+            variable.collect do |var|
               context[context_variable_name] = var
-              partial.render_to_output_buffer(context, output)
+              partial.render(context)
             end
           else
             context[context_variable_name] = variable
-            partial.render_to_output_buffer(context, output)
+            partial.render(context)
           end
         end
       ensure
         context.template_name = old_template_name
         context.partial = old_partial
       end
-
-      output
     end
 
+    private
+
     alias_method :parse_context, :options
     private :parse_context
 
-    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+    def load_cached_partial(template_name, context)
-      def children
+      cached_partials = context.registers[:cached_partials] || {}
-        [
+
-          @node.template_name_expr,
+      if cached = cached_partials[template_name]
-          @node.variable_name_expr,
+        return cached
-        ] + @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,12 +20,10 @@ module Liquid
       @variable = markup.strip
     end
 
-    def render_to_output_buffer(context, output)
+    def render(context)
       value = context.environments.first[@variable] ||= 0
       context.environments.first[@variable] = value + 1
-
+      value.to_s
-      output << value.to_s
-      output
     end
   end
 

lib/liquid/tags/raw.rb

@@ -13,18 +13,17 @@ module Liquid
       @body = ''
       while token = tokens.shift
         if token =~ FullTokenPossiblyInvalid
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != "".freeze
+          @body << $1 if $1 != "".freeze
-          return if block_delimiter == Regexp.last_match(2)
+          return if block_delimiter == $2
         end
         @body << token unless token.empty?
       end
 
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)
+      raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name))
     end
 
-    def render_to_output_buffer(_context, output)
+    def render(_context)
-      output << @body
+      @body
-      output
     end
 
     def nodelist
@@ -39,7 +38,7 @@ module Liquid
 
     def ensure_valid_markup(tag_name, markup, parse_context)
       unless markup =~ Syntax
-        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name)
+        raise SyntaxError.new(parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name))
       end
     end
   end

lib/liquid/tags/render.rb

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

lib/liquid/tags/table_row.rb

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

lib/liquid/tags/unless.rb

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

lib/liquid/template.rb

@@ -50,7 +50,7 @@ module Liquid
       private
 
       def lookup_class(name)
-        Object.const_get(name)
+        name.split("::").reject(&:empty?).reduce(Object) { |scope, const| scope.const_get(const) }
       end
     end
 
@@ -143,12 +143,7 @@ module Liquid
     end
 
     def instance_assigns
-      @instance_assigns ||= []
+      @instance_assigns ||= {}
-    end
-
-    def new_outer_scope
-      @instance_assigns.unshift(last = {})
-      last
     end
 
     def errors
@@ -177,27 +172,24 @@ module Liquid
         c = args.shift
 
         if @rethrow_errors
-          c.exception_renderer = ->(_e) { raise }
+          c.exception_renderer = ->(e) { raise }
         end
 
         c
       when Liquid::Drop
         drop = args.shift
-        drop.context = Context.new([drop, assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
+        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when Hash
-        Context.new([args.shift, assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
+        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when nil
-        Context.new([assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
+        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
       else
         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)
 
@@ -212,9 +204,10 @@ module Liquid
       begin
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
-        with_profiling(context) do
+        result = with_profiling(context) do
-          @root.render_to_output_buffer(context, output || '')
+          @root.render(context)
         end
+        result.respond_to?(:join) ? result.join : result
       rescue Liquid::MemoryError => e
         context.handle_error(e)
       ensure
@@ -227,10 +220,6 @@ 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,35 +1,29 @@
 module Liquid
   class Tokenizer
-    attr_reader :line_number, :for_liquid_tag
+    attr_reader :line_number
 
-    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
+    def initialize(source, line_numbers = false)
       @source = source
-      @line_number = line_number || (line_numbers ? 1 : nil)
+      @line_number = line_numbers ? 1 : nil
-      @for_liquid_tag = for_liquid_tag
       @tokens = tokenize
     end
 
     def shift
-      (token = @tokens.shift) || return
+      token = @tokens.shift
-
+      @line_number += token.count("\n") if @line_number && token
-      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
-      tokens.shift if tokens[0]&.empty?
+      tokens.shift if tokens[0] && tokens[0].empty?
 
       tokens
     end

lib/liquid/usage.rb

@@ -1,6 +0,0 @@
-module Liquid
-  module Usage
-    def self.increment(name)
-    end
-  end
-end

lib/liquid/utils.rb

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

lib/liquid/variable.rb

@@ -10,16 +10,10 @@ 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)
@@ -41,17 +35,17 @@ module Liquid
 
     def lax_parse(markup)
       @filters = []
-      return unless markup =~ MarkupWithQuotedFragment
+      return unless markup =~ /(#{QuotedFragment})(.*)/om
 
-      name_markup = Regexp.last_match(1)
+      name_markup = $1
-      filter_markup = Regexp.last_match(2)
+      filter_markup = $2
       @name = Expression.parse(name_markup)
-      if filter_markup =~ FilterMarkupRegex
+      if filter_markup =~ /#{FilterSeparator}\s*(.*)/om
-        filters = Regexp.last_match(1).scan(FilterParser)
+        filters = $1.scan(FilterParser)
         filters.each do |f|
           next unless f =~ /\w+/
           filtername = Regexp.last_match(0)
-          filterargs = f.scan(FilterArgsRegex).flatten
+          filterargs = f.scan(/(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o).flatten
           @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
@@ -85,43 +79,31 @@ 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 = nil
+      keyword_args = {}
       unparsed_args.each do |a|
-        if matches = a.match(JustTagAttributes)
+        if matches = a.match(/\A#{TagAttributes}\z/o)
-          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 if keyword_args
+      result << keyword_args unless keyword_args.empty?
       result
     end
 
     def evaluate_filter_expressions(context, filter_args, filter_kwargs)
-      parsed_args = filter_args.map { |expr| context.evaluate(expr) }
+      parsed_args = filter_args.map{ |expr| context.evaluate(expr) }
       if filter_kwargs
         parsed_kwargs = {}
         filter_kwargs.each do |key, expr|
@@ -150,11 +132,5 @@ 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].freeze
+    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze]
 
     attr_reader :name, :lookups
 
@@ -14,7 +14,7 @@ module Liquid
 
       name = lookups.shift
       if name =~ SQUARE_BRACKETED
-        name = Expression.parse(Regexp.last_match(1))
+        name = Expression.parse($1)
       end
       @name = name
 
@@ -24,7 +24,7 @@ module Liquid
       @lookups.each_index do |i|
         lookup = lookups[i]
         if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse(Regexp.last_match(1))
+          lookups[i] = Expression.parse($1)
         elsif COMMAND_METHODS.include?(lookup)
           @command_flags |= 1 << i
         end
@@ -78,11 +78,5 @@ 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,5 +1,4 @@
 # encoding: utf-8
-
 module Liquid
-  VERSION = "4.0.3".freeze
+  VERSION = "4.0.0"
 end

liquid.gemspec

@@ -1,7 +1,6 @@
 # encoding: utf-8
-
 lib = File.expand_path('../lib/', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib)
 
 require "liquid/version"
 
@@ -16,7 +15,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.4.0"
+  s.required_ruby_version     = ">= 2.1.0"
   s.required_rubygems_version = ">= 1.3.7"
 
   s.test_files  = Dir.glob("{test}/**/*")
@@ -26,6 +25,6 @@ Gem::Specification.new do |s|
 
   s.require_path = "lib"
 
-  s.add_development_dependency('rake', '~> 11.3')
+  s.add_development_dependency 'rake', '~> 11.3'
-  s.add_development_dependency('minitest')
+  s.add_development_dependency 'minitest'
 end

performance/memory_profile.rb

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

performance/shopify/comment_form.rb

@@ -5,14 +5,14 @@ class CommentForm < Liquid::Block
     super
 
     if markup =~ Syntax
-      @variable_name = Regexp.last_match(1)
+      @variable_name = $1
       @attributes = {}
     else
-      raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]"
+      raise SyntaxError.new("Syntax Error in 'comment_form' - Valid syntax: comment_form [article]")
     end
   end
 
-  def render_to_output_buffer(context, output)
+  def render(context)
     article = context[@variable_name]
 
     context.stack do
@@ -20,12 +20,10 @@ class CommentForm < Liquid::Block
         'posted_successfully?' => context.registers[:posted_successfully],
         'errors' => context['comment.errors'],
         'author' => context['comment.author'],
-        'email' => context['comment.email'],
+        'email'  => context['comment.email'],
-        'body' => context['comment.body'],
+        'body'   => context['comment.body']
       }
-
+      wrap_in_form(article, render_all(@nodelist, context))
-      output << wrap_in_form(article, render_all(@nodelist, context, output))
-      output
     end
   end
 

performance/shopify/database.rb

@@ -16,10 +16,9 @@ module Database
       end
 
       # key the tables by handles, as this is how liquid expects it.
-      db = db.each_with_object({}) do |(key, values), assigns|
+      db = db.inject({}) do |assigns, (key, values)|
-        assigns[key] = values.each_with_object({}) do |v, h|
+        assigns[key] = values.inject({}) { |h, v| h[v['handle']] = v; h; }
-          h[v['handle']] = v
+        assigns
-        end
       end
 
       # Some standard direct accessors so that the specialized templates
@@ -31,8 +30,8 @@ module Database
 
       db['cart']       = {
         'total_price' => db['line_items'].values.inject(0) { |sum, item| sum += item['line_price'] * item['quantity'] },
-        'item_count' => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
+        'item_count'  => db['line_items'].values.inject(0) { |sum, item| sum += item['quantity'] },
-        'items' => db['line_items'].values,
+        'items'       => db['line_items'].values
       }
 
       db
@@ -41,6 +40,6 @@ module Database
 end
 
 if __FILE__ == $PROGRAM_NAME
-  p(Database.tables['collections']['frontpage'].keys)
+  p Database.tables['collections']['frontpage'].keys
   # p Database.tables['blog']['articles']
 end

performance/shopify/json_filter.rb

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

performance/shopify/liquid.rb

@@ -1,4 +1,4 @@
-$LOAD_PATH.unshift(__dir__ + '/../../lib')
+$:.unshift __dir__ + '/../../lib'
 require_relative '../../lib/liquid'
 
 require_relative 'comment_form'
@@ -9,11 +9,11 @@ require_relative 'shop_filter'
 require_relative 'tag_filter'
 require_relative 'weight_filter'
 
-Liquid::Template.register_tag('paginate', Paginate)
+Liquid::Template.register_tag 'paginate', Paginate
-Liquid::Template.register_tag('form', CommentForm)
+Liquid::Template.register_tag 'form', CommentForm
 
-Liquid::Template.register_filter(JsonFilter)
+Liquid::Template.register_filter JsonFilter
-Liquid::Template.register_filter(MoneyFilter)
+Liquid::Template.register_filter MoneyFilter
-Liquid::Template.register_filter(WeightFilter)
+Liquid::Template.register_filter WeightFilter
-Liquid::Template.register_filter(ShopFilter)
+Liquid::Template.register_filter ShopFilter
-Liquid::Template.register_filter(TagFilter)
+Liquid::Template.register_filter TagFilter

performance/shopify/money_filter.rb

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

performance/shopify/paginate.rb

@@ -1,13 +1,13 @@
 class Paginate < Liquid::Block
-  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
+  Syntax     = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
 
   def initialize(tag_name, markup, options)
     super
 
     if markup =~ Syntax
-      @collection_name = Regexp.last_match(1)
+      @collection_name = $1
-      @page_size = if Regexp.last_match(2)
+      @page_size = if $2
-        Regexp.last_match(3).to_i
+        $3.to_i
       else
         20
       end
@@ -17,27 +17,27 @@ class Paginate < Liquid::Block
         @attributes[key] = value
       end
     else
-      raise SyntaxError, "Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number"
+      raise SyntaxError.new("Syntax Error in tag 'paginate' - Valid syntax: paginate [collection] by number")
     end
   end
 
-  def render_to_output_buffer(context, output)
+  def render(context)
     @context = context
 
     context.stack do
-      current_page = context['current_page'].to_i
+      current_page  = context['current_page'].to_i
 
       pagination = {
-        'page_size' => @page_size,
+        'page_size'      => @page_size,
-        'current_page' => 5,
+        'current_page'   => 5,
-        'current_offset' => @page_size * 5,
+        'current_offset' => @page_size * 5
       }
 
       context['paginate'] = pagination
 
-      collection_size = context[@collection_name].size
+      collection_size  = context[@collection_name].size
 
-      raise ArgumentError, "Cannot paginate array '#{@collection_name}'. Not found." if collection_size.nil?
+      raise ArgumentError.new("Cannot paginate array '#{@collection_name}'. Not found.") if collection_size.nil?
 
       page_count = (collection_size.to_f / @page_size.to_f).to_f.ceil + 1
 

performance/shopify/shop_filter.rb

@@ -52,7 +52,7 @@ module ShopFilter
   end
 
   def product_img_url(url, style = 'small')
-    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
+    unless url =~ /\Aproducts\/([\w\-\_]+)\.(\w{2,4})/
       raise ArgumentError, 'filter "size" can only be called on product images'
     end
 
@@ -60,7 +60,7 @@ module ShopFilter
     when 'original'
       return '/files/shops/random_number/' + url
     when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
-      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
+      "/files/shops/random_number/products/#{$1}_#{style}.#{$2}"
     else
       raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
     end
@@ -70,14 +70,16 @@ module ShopFilter
     html = []
     html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
 
-    paginate['parts'].each do |part|
+    for part in paginate['parts']
-      html << if part['is_link']
+
-        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+      if part['is_link']
+        html << %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
       elsif part['title'].to_i == paginate['current_page'].to_i
-        %(<span class="page current">#{part['title']}</span>)
+        html << %(<span class="page current">#{part['title']}</span>)
       else
-        %(<span class="deco">#{part['title']}</span>)
+        html << %(<span class="deco">#{part['title']}</span>)
       end
+
     end
 
     html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']

performance/shopify/tag_filter.rb

@@ -13,11 +13,11 @@ module TagFilter
 
   def link_to_add_tag(label, tag)
     tags = (@context['current_tags'] + [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
   end
 
   def link_to_remove_tag(label, tag)
     tags = (@context['current_tags'] - [tag]).uniq
-    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join('+')}\">#{label}</a>"
+    "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tags.join("+")}\">#{label}</a>"
   end
 end

performance/shopify/weight_filter.rb

@@ -1,6 +1,6 @@
 module WeightFilter
   def weight(grams)
-    format("%.2f", grams / 1000)
+    sprintf("%.2f", grams / 1000)
   end
 
   def weight_with_unit(grams)

performance/theme_runner.rb

@@ -31,7 +31,7 @@ class ThemeRunner
       {
         liquid: File.read(test),
         layout: (File.file?(theme_path) ? File.read(theme_path) : nil),
-        template_name: test,
+        template_name: test
       }
     end.compact
 

test/integration/blank_test.rb

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

test/integration/block_test.rb

@@ -1,12 +0,0 @@
-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/drop_test.rb

@@ -201,9 +201,9 @@ class DropsTest < Minitest::Test
   end
 
   def test_scope_though_proc
-    assert_equal '1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] })
+    assert_equal '1', Liquid::Template.parse('{{ s }}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] })
-    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1])
+    assert_equal '2', Liquid::Template.parse('{%for i in dummy%}{{ s }}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
-    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc { |c| c['context.scopes'] }, 'dummy' => [1])
+    assert_equal '3', Liquid::Template.parse('{%for i in dummy%}{%for i in dummy%}{{ s }}{%endfor%}{%endfor%}').render!('context' => ContextDrop.new, 's' => proc{ |c| c['context.scopes'] }, 'dummy' => [1])
   end
 
   def test_scope_with_assigns
@@ -241,7 +241,7 @@ class DropsTest < Minitest::Test
   end
 
   def test_some_enumerable_methods_still_get_invoked
-    [:count, :max].each do |method|
+    [ :count, :max ].each do |method|
       assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
       assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
       assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
@@ -250,7 +250,7 @@ class DropsTest < Minitest::Test
 
     assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)
 
-    [:min, :first].each do |method|
+    [ :min, :first ].each do |method|
       assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
       assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
       assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)

test/integration/error_handling_test.rb

@@ -83,14 +83,15 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_with_line_numbers_adds_numbers_to_parser_errors
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
+      Liquid::Template.parse(%q(
           foobar
 
           {% "cat" | foobar %}
 
           bla
-        ',
+        ),
-        line_numbers: true)
+        line_numbers: true
+      )
     end
 
     assert_match(/Liquid syntax error \(line 4\)/, err.message)
@@ -98,14 +99,15 @@ class ErrorHandlingTest < Minitest::Test
 
   def test_with_line_numbers_adds_numbers_to_parser_errors_with_whitespace_trim
     err = assert_raises(SyntaxError) do
-      Liquid::Template.parse('
+      Liquid::Template.parse(%q(
           foobar
 
           {%- "cat" | foobar -%}
 
           bla
-        ',
+        ),
-        line_numbers: true)
+        line_numbers: true
+      )
     end
 
     assert_match(/Liquid syntax error \(line 4\)/, err.message)
@@ -120,7 +122,8 @@ class ErrorHandlingTest < Minitest::Test
         bla
             ',
       error_mode: :warn,
-      line_numbers: true)
+      line_numbers: true
+                                     )
 
     assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
       template.warnings.map(&:message)
@@ -136,7 +139,8 @@ class ErrorHandlingTest < Minitest::Test
           bla
                 ',
         error_mode: :strict,
-        line_numbers: true)
+        line_numbers: true
+                            )
     end
 
     assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
@@ -153,7 +157,8 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
                 ',
-        line_numbers: true)
+        line_numbers: true
+                            )
     end
 
     assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
@@ -200,7 +205,7 @@ class ErrorHandlingTest < Minitest::Test
   def test_default_exception_renderer_with_internal_error
     template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
 
-    output = template.render('errors' => ErrorDrop.new)
+    output = template.render({ 'errors' => ErrorDrop.new })
 
     assert_equal 'This is a runtime error: Liquid error (line 1): internal', output
     assert_equal [Liquid::InternalError], template.errors.map(&:class)
@@ -212,7 +217,7 @@ class ErrorHandlingTest < Minitest::Test
     Liquid::Template.default_exception_renderer = ->(e) { exceptions << e; '' }
     template = Liquid::Template.parse('This is a runtime error: {{ errors.argument_error }}')
 
-    output = template.render('errors' => ErrorDrop.new)
+    output = template.render({ 'errors' => ErrorDrop.new })
 
     assert_equal 'This is a runtime error: ', output
     assert_equal [Liquid::ArgumentError], template.errors.map(&:class)
@@ -234,7 +239,7 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   class TestFileSystem
-    def read_template_file(_template_path)
+    def read_template_file(template_path)
       "{{ errors.argument_error }}"
     end
   end

test/integration/filter_test.rb

@@ -2,23 +2,23 @@ require 'test_helper'
 
 module MoneyFilter
   def money(input)
-    format(' %d$ ', input)
+    sprintf(' %d$ ', input)
   end
 
   def money_with_underscore(input)
-    format(' %d$ ', input)
+    sprintf(' %d$ ', input)
   end
 end
 
 module CanadianMoneyFilter
   def money(input)
-    format(' %d$ CAD ', input)
+    sprintf(' %d$ CAD ', input)
   end
 end
 
 module SubstituteFilter
   def substitute(input, params = {})
-    input.gsub(/%\{(\w+)\}/) { |_match| params[Regexp.last_match(1)] }
+    input.gsub(/%\{(\w+)\}/) { |match| params[$1] }
   end
 end
 
@@ -26,7 +26,7 @@ class FiltersTest < Minitest::Test
   include Liquid
 
   module OverrideObjectMethodFilter
-    def tap(_input)
+    def tap(input)
       "tap overridden"
     end
   end
@@ -149,7 +149,7 @@ class FiltersTest < Minitest::Test
     assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
 
     # tap still treated as a non-existent filter
-    assert_equal "1000", Template.parse("{{var | tap}}").render!('var' => 1000)
+    assert_equal "1000", Template.parse("{{var | tap}}").render!({ 'var' => 1000 })
   end
 end
 

test/integration/hash_ordering_test.rb

@@ -3,13 +3,13 @@ require 'test_helper'
 class HashOrderingTest < Minitest::Test
   module MoneyFilter
     def money(input)
-      format(' %d$ ', input)
+      sprintf(' %d$ ', input)
     end
   end
 
   module CanadianMoneyFilter
     def money(input)
-      format(' %d$ CAD ', input)
+      sprintf(' %d$ CAD ', input)
     end
   end
 

test/integration/output_test.rb

@@ -1,7 +1,7 @@
 require 'test_helper'
 
 module FunnyFilter
-  def make_funny(_input)
+  def make_funny(input)
     'LOL'
   end
 
@@ -32,7 +32,7 @@ class OutputTest < Minitest::Test
   def setup
     @assigns = {
       'best_cars' => 'bmw',
-      'car' => { 'bmw' => 'good', 'gm' => 'bad' },
+      'car' => { 'bmw' => 'good', 'gm' => 'bad' }
     }
   end
 

test/integration/parse_tree_visitor_test.rb

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

test/integration/render_profiling_test.rb

@@ -128,7 +128,7 @@ class RenderProfilingTest < Minitest::Test
     t.render!
 
     timing_count = 0
-    t.profiler.each do |_timing|
+    t.profiler.each do |timing|
       timing_count += 1
     end
 
@@ -145,7 +145,7 @@ class RenderProfilingTest < Minitest::Test
 
   def test_profiling_marks_children_of_for_blocks
     t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
-    t.render!("collection" => ["one", "two"])
+    t.render!({ "collection" => ["one", "two"] })
 
     assert_equal 1, t.profiler.length
     # Will profile each invocation of the for block

test/integration/standard_filter_test.rb

@@ -17,7 +17,7 @@ class TestThing
     "woot: #{@foo}"
   end
 
-  def [](_whatever)
+  def [](whatever)
     to_s
   end
 
@@ -37,7 +37,7 @@ class TestEnumerable < Liquid::Drop
   include Enumerable
 
   def each(&block)
-    [{ "foo" => 1, "bar" => 2 }, { "foo" => 2, "bar" => 1 }, { "foo" => 3, "bar" => 3 }].each(&block)
+    [ { "foo" => 1, "bar" => 2 }, { "foo" => 2, "bar" => 1 }, { "foo" => 3, "bar" => 3 } ].each(&block)
   end
 end
 
@@ -158,10 +158,6 @@ class StandardFiltersTest < Minitest::Test
     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
@@ -181,9 +177,6 @@ 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
@@ -197,114 +190,34 @@ 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" },
       { "handle" => "beta" },
       { "price" => 1, "handle" => "gamma" },
       { "handle" => "delta" },
-      { "price" => 2, "handle" => "epsilon" },
+      { "price" => 2, "handle" => "epsilon" }
     ]
     expectation = [
       { "price" => 1, "handle" => "gamma" },
       { "price" => 2, "handle" => "epsilon" },
       { "price" => 4, "handle" => "alpha" },
       { "handle" => "delta" },
-      { "handle" => "beta" },
+      { "handle" => "beta" }
     ]
     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)
+    assert_equal [{ a: 1, b: 2 }], @filters.sort({ a: 1, b: 2 })
   end
 
   def test_numerical_vs_lexicographical_sort
@@ -326,34 +239,10 @@ 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
@@ -380,7 +269,7 @@ class StandardFiltersTest < Minitest::Test
 
   def test_map_on_hashes
     assert_template_result "4217", '{{ thing | map: "foo" | map: "bar" }}',
-      "thing" => { "foo" => [{ "bar" => 42 }, { "bar" => 17 }] }
+      "thing" => { "foo" => [ { "bar" => 42 }, { "bar" => 17 } ] }
   end
 
   def test_legacy_map_on_hashes_with_dynamic_key
@@ -397,7 +286,7 @@ class StandardFiltersTest < Minitest::Test
 
   def test_map_over_proc
     drop = TestDrop.new
-    p = proc { drop }
+    p = proc{ drop }
     templ = '{{ procs | map: "test" }}'
     assert_template_result "testfoo", templ, "procs" => [p]
   end
@@ -405,10 +294,10 @@ class StandardFiltersTest < Minitest::Test
   def test_map_over_drops_returning_procs
     drops = [
       {
-        "proc" => -> { "foo" },
+        "proc" => ->{ "foo" },
       },
       {
-        "proc" => -> { "bar" },
+        "proc" => ->{ "bar" },
       },
     ]
     templ = '{{ drops | map: "proc" }}'
@@ -419,29 +308,6 @@ 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
@@ -472,9 +338,9 @@ 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.to_s, @filters.date('now', '%Y')
+    assert_equal "#{Date.today.year}", @filters.date('now', '%Y')
-    assert_equal Date.today.year.to_s, @filters.date('today', '%Y')
+    assert_equal "#{Date.today.year}", @filters.date('today', '%Y')
-    assert_equal Date.today.year.to_s, @filters.date('Today', '%Y')
+    assert_equal "#{Date.today.year}", @filters.date('Today', '%Y')
 
     assert_nil @filters.date(nil, "%B")
 
@@ -630,28 +496,6 @@ 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)
@@ -692,78 +536,6 @@ 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

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

@@ -23,16 +23,16 @@ class ForTagTest < Minitest::Test
   yo
 
 HERE
-    template = <<~HERE
+    template = <<HERE
-      {%for item in array%}
+{%for item in array%}
-        yo
+  yo
-      {%endfor%}
+{%endfor%}
-    HERE
+HERE
     assert_template_result(expected, template, 'array' => [1, 2, 3])
   end
 
   def test_for_reversed
-    assigns = { 'array' => [1, 2, 3] }
+    assigns = { 'array' => [ 1, 2, 3] }
     assert_template_result('321', '{%for item in array reversed %}{{item}}{%endfor%}', assigns)
   end
 
@@ -48,6 +48,10 @@ HERE
 
   def test_for_with_variable_range
     assert_template_result(' 1  2  3 ', '{%for item in (1..foobar) %} {{item}} {%endfor%}', "foobar" => 3)
+    assert_template_result(' 1.0  2.0  3.0 ', '{%for item in foobar %} {{item}} {%endfor%}', "foobar" => (1..3.0))
+    assert_template_result(' 1.0  2.0  3.0 ', '{%for item in foobar %} {{item}} {%endfor%}', "foobar" => (1.0..3))
+    assert_template_result(' 1.0  2.0  3.0 ', '{%for item in foobar %} {{item}} {%endfor%}', "foobar" => (1.0..3.0))
+    assert_template_result(' 1.5  2.5 ', '{%for item in foobar %} {{item}} {%endfor%}', "foobar" => (1.5..3))
   end
 
   def test_for_with_hash_value_range
@@ -103,34 +107,6 @@ 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
@@ -187,7 +163,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%}
@@ -206,7 +182,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/if_else_tag_test.rb

@@ -132,7 +132,7 @@ class IfElseTagTest < Minitest::Test
   end
 
   def test_syntax_error_no_variable
-    assert_raises(SyntaxError) { assert_template_result('', '{% if jerry == 1 %}') }
+    assert_raises(SyntaxError){ assert_template_result('', '{% if jerry == 1 %}') }
   end
 
   def test_syntax_error_no_expression

test/integration/tags/include_tag_test.rb

@@ -30,9 +30,6 @@ class TestFileSystem
     when 'assignments'
       "{% assign foo = 'bar' %}"
 
-    when 'break'
-      "{% break %}"
-
     else
       template_path
     end
@@ -40,14 +37,14 @@ class TestFileSystem
 end
 
 class OtherFileSystem
-  def read_template_file(_template_path)
+  def read_template_file(template_path)
     'from OtherFileSystem'
   end
 end
 
 class CountingFileSystem
   attr_reader :count
-  def read_template_file(_template_path)
+  def read_template_file(template_path)
     @count ||= 0
     @count += 1
     'from CountingFileSystem'
@@ -59,16 +56,15 @@ class CustomInclude < Liquid::Tag
 
   def initialize(tag_name, markup, tokens)
     markup =~ Syntax
-    @template_name = Regexp.last_match(1)
+    @template_name = $1
     super
   end
 
   def parse(tokens)
   end
 
-  def render_to_output_buffer(_context, output)
+  def render(context)
-    output << @template_name[1..-2]
+    @template_name[1..-2]
-    output
   end
 end
 
@@ -86,7 +82,7 @@ class IncludeTagTest < Minitest::Test
 
   def test_include_tag_with
     assert_template_result "Product: Draft 151cm ",
-      "{% include 'product' with products[0] %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }]
+      "{% include 'product' with products[0] %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
   end
 
   def test_include_tag_with_default_name
@@ -96,7 +92,7 @@ class IncludeTagTest < Minitest::Test
 
   def test_include_tag_for
     assert_template_result "Product: Draft 151cm Product: Element 155cm ",
-      "{% include 'product' for products %}", "products" => [{ 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' }]
+      "{% include 'product' for products %}", "products" => [ { 'title' => 'Draft 151cm' }, { 'title' => 'Element 155cm' } ]
   end
 
   def test_include_tag_with_local_variables
@@ -134,7 +130,7 @@ class IncludeTagTest < Minitest::Test
 
   def test_recursively_included_template_does_not_produce_endless_loop
     infinite_file_system = Class.new do
-      def read_template_file(_template_path)
+      def read_template_file(template_path)
         "-{% include 'loop' %}"
       end
     end
@@ -246,9 +242,4 @@ class IncludeTagTest < Minitest::Test
 
     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/increment_tag_test.rb

@@ -13,11 +13,11 @@ class IncrementTagTest < Minitest::Test
   end
 
   def test_dec
-    assert_template_result('9', '{%decrement port %}', 'port' => 10)
+    assert_template_result('9', '{%decrement port %}', { 'port' => 10 })
     assert_template_result('-1 -2', '{%decrement port %} {%decrement port%}', {})
     assert_template_result('1 5 2 2 5',
       '{%increment port %} {%increment starboard%} ' \
       '{%increment port %} {%decrement port%} ' \
-      '{%decrement starboard %}', 'port' => 1, 'starboard' => 5)
+      '{%decrement starboard %}', { 'port' => 1, 'starboard' => 5 })
   end
 end

test/integration/tags/liquid_tag_test.rb

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

@@ -1,149 +0,0 @@
-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/tags/standard_tag_test.rb

@@ -69,7 +69,7 @@ class StandardTagTest < Minitest::Test
     assert_raises(SyntaxError) do
       assert_template_result('content foo content foo ',
         '{{ var2 }}{% capture %}{{ var }} foo {% endcapture %}{{ var2 }}{{ var2 }}',
-        'var' => 'content')
+        { 'var' => 'content' })
     end
   end
 
@@ -183,32 +183,32 @@ class StandardTagTest < Minitest::Test
 
   def test_case_when_or
     code = '{% case condition %}{% when 1 or 2 or 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 2)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 3)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
-    assert_template_result(' its 4 ', code, 'condition' => 4)
+    assert_template_result(' its 4 ', code, { 'condition' => 4 })
-    assert_template_result('', code, 'condition' => 5)
+    assert_template_result('', code, { 'condition' => 5 })
 
     code = '{% case condition %}{% when 1 or "string" or null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 'string')
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => nil)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
-    assert_template_result('', code, 'condition' => 'something else')
+    assert_template_result('', code, { 'condition' => 'something else' })
   end
 
   def test_case_when_comma
     code = '{% case condition %}{% when 1, 2, 3 %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 2)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 2 })
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 3)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 3 })
-    assert_template_result(' its 4 ', code, 'condition' => 4)
+    assert_template_result(' its 4 ', code, { 'condition' => 4 })
-    assert_template_result('', code, 'condition' => 5)
+    assert_template_result('', code, { 'condition' => 5 })
 
     code = '{% case condition %}{% when 1, "string", null %} its 1 or 2 or 3 {% when 4 %} its 4 {% endcase %}'
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 1)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 1 })
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => 'string')
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => 'string' })
-    assert_template_result(' its 1 or 2 or 3 ', code, 'condition' => nil)
+    assert_template_result(' its 1 or 2 or 3 ', code, { 'condition' => nil })
-    assert_template_result('', code, 'condition' => 'something else')
+    assert_template_result('', code, { 'condition' => 'something else' })
   end
 
   def test_assign
@@ -283,10 +283,10 @@ class StandardTagTest < Minitest::Test
   end
 
   def test_ifchanged
-    assigns = { 'array' => [1, 1, 2, 2, 3, 3] }
+    assigns = { 'array' => [ 1, 1, 2, 2, 3, 3] }
     assert_template_result('123', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
 
-    assigns = { 'array' => [1, 1, 1, 1] }
+    assigns = { 'array' => [ 1, 1, 1, 1] }
     assert_template_result('1', '{%for item in array%}{%ifchanged%}{{item}}{% endifchanged %}{%endfor%}', assigns)
   end
 

test/integration/template_test.rb

@@ -42,18 +42,6 @@ class TemplateTest < Minitest::Test
     assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
   end
 
-  def test_instance_assigns_persist_on_same_template_object_between_many_parses
-    t = Template.new
-    assert_equal 'from instance assigns', t.parse("{% assign foo = 'from instance assigns' %}{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns second', t.parse("{% assign foo = 'from instance assigns second' %}{{ foo }}").render!
-    assert_equal 'from instance assigns second', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns second', t.parse("{{ foo }}").render!
-    assert_equal 'from instance assigns second', t.parse("{{ foo }}").render!
-  end
-
   def test_warnings_is_not_exponential_time
     str = "false"
     100.times do
@@ -70,14 +58,6 @@ class TemplateTest < Minitest::Test
     assert_equal 'foofoo', t.render!
   end
 
-  def test_instance_assigns_persist_on_same_template_parsing_between_many_renders
-    t = Template.new.parse("{{ foo }}{% assign foo = 'foo' %}{{ foo }}")
-    assert_equal 'foo', t.render!
-    assert_equal 'foofoo', t.render!
-    assert_equal 'foofoo', t.render!
-    assert_equal 'foofoo', t.render!
-  end
-
   def test_custom_assigns_do_not_persist_on_same_template
     t = Template.new
     assert_equal 'from custom assigns', t.parse("{{ foo }}").render!('foo' => 'from custom assigns')
@@ -159,16 +139,6 @@ 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 %}")
 
@@ -217,14 +187,6 @@ 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 %}")
@@ -244,7 +206,7 @@ class TemplateTest < Minitest::Test
   end
 
   def test_render_bang_force_rethrow_errors_on_passed_context
-    context = Context.new('drop' => ErroneousDrop.new)
+    context = Context.new({ 'drop' => ErroneousDrop.new })
     t = Template.new.parse('{{ drop.bad_method }}')
 
     e = assert_raises RuntimeError do
@@ -287,7 +249,7 @@ class TemplateTest < Minitest::Test
 
   def test_undefined_variables
     t = Template.parse("{{x}} {{y}} {{z.a}} {{z.b}} {{z.c.d}}")
-    result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true)
+    result = t.render({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
 
     assert_equal '33  32  ', result
     assert_equal 3, t.errors.count
@@ -299,27 +261,18 @@ 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}}")
 
     assert_raises UndefinedVariable do
-      t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, strict_variables: true)
+      t.render!({ 'x' => 33, 'z' => { 'a' => 32, 'c' => { 'e' => 31 } } }, { strict_variables: true })
     end
   end
 
   def test_undefined_drop_methods
     d = DropWithUndefinedMethod.new
     t = Template.new.parse('{{ foo }} {{ woot }}')
-    result = t.render(d, strict_variables: true)
+    result = t.render(d, { strict_variables: true })
 
     assert_equal 'foo ', result
     assert_equal 1, t.errors.count
@@ -331,7 +284,7 @@ class TemplateTest < Minitest::Test
     t = Template.new.parse('{{ foo }} {{ woot }}')
 
     assert_raises UndefinedDropMethod do
-      t.render!(d, strict_variables: true)
+      t.render!(d, { strict_variables: true })
     end
   end
 
@@ -342,7 +295,7 @@ class TemplateTest < Minitest::Test
         "-#{v}-"
       end
     end
-    result = t.render({ 'a' => 123, 'x' => 'foo' }, filters: [filters], strict_filters: true)
+    result = t.render({ 'a' => 123, 'x' => 'foo' }, { filters: [filters], strict_filters: true })
 
     assert_equal '123 ', result
     assert_equal 1, t.errors.count
@@ -354,17 +307,17 @@ class TemplateTest < Minitest::Test
     t = Template.parse("{{x | somefilter1 | upcase | somefilter2}}")
 
     assert_raises UndefinedFilter do
-      t.render!({ 'x' => 'foo' }, strict_filters: true)
+      t.render!({ 'x' => 'foo' }, { strict_filters: true })
     end
   end
 
   def test_using_range_literal_works_as_expected
     t = Template.parse("{% assign foo = (x..y) %}{{ foo }}")
-    result = t.render('x' => 1, 'y' => 5)
+    result = t.render({ 'x' => 1, 'y' => 5 })
     assert_equal '1..5', result
 
     t = Template.parse("{% assign nums = (x..y) %}{% for num in nums %}{{ num }}{% endfor %}")
-    result = t.render('x' => 1, 'y' => 5)
+    result = t.render({ 'x' => 1, 'y' => 5 })
     assert_equal '12345', result
   end
 end

test/integration/trim_mode_test.rb

@@ -76,14 +76,14 @@ class TrimModeTest < Minitest::Test
         </p>
       </div>
     END_TEMPLATE
-    expected = <<~END_EXPECTED
+    expected = <<-END_EXPECTED
-            <div>
+      <div>
-              <p>
+        <p>
-      #{whitespace}
+#{whitespace}
-                yes
+          yes
-      #{whitespace}
+#{whitespace}
-              </p>
+        </p>
-            </div>
+      </div>
     END_EXPECTED
     assert_template_result(expected, text)
 
@@ -96,12 +96,12 @@ class TrimModeTest < Minitest::Test
         </p>
       </div>
     END_TEMPLATE
-    expected = <<~END_EXPECTED
+    expected = <<-END_EXPECTED
-            <div>
+      <div>
-              <p>
+        <p>
-      #{whitespace}
+#{whitespace}
-              </p>
+        </p>
-            </div>
+      </div>
     END_EXPECTED
     assert_template_result(expected, text)
   end
@@ -337,12 +337,12 @@ class TrimModeTest < Minitest::Test
         </p>
       </div>
     END_TEMPLATE
-    expected = <<~END_EXPECTED
+    expected = <<-END_EXPECTED
-            <div>
+      <div>
-              <p>
+        <p>
-      #{whitespace}
+#{whitespace}
-              </p>
+        </p>
-            </div>
+      </div>
     END_EXPECTED
     assert_template_result(expected, text)
   end
@@ -496,10 +496,6 @@ 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
@@ -513,16 +509,16 @@ class TrimModeTest < Minitest::Test
         {% endraw %}
       </div>
     END_TEMPLATE
-    expected = <<~END_EXPECTED
+    expected = <<-END_EXPECTED
-            <div>
+      <div>
-      #{whitespace}
+#{whitespace}
-                {%- if true -%}
+          {%- if true -%}
-                  <p>
+            <p>
-                    {{- 'John' -}}
+              {{- 'John' -}}
-                  </p>
+            </p>
-                {%- endif -%}
+          {%- endif -%}
-      #{whitespace}
+#{whitespace}
-            </div>
+      </div>
     END_EXPECTED
     assert_template_result(expected, text)
   end

test/integration/variable_test.rb

@@ -76,7 +76,7 @@ class VariableTest < Minitest::Test
 
   def test_hash_with_default_proc
     template = Template.parse(%(Hello {{ test }}))
-    assigns = Hash.new { |_h, k| raise "Unknown variable '#{k}'" }
+    assigns = Hash.new { |h, k| raise "Unknown variable '#{k}'" }
     assigns['test'] = 'Tobi'
     assert_equal 'Hello Tobi', template.render!(assigns)
     assigns.delete('test')
@@ -89,8 +89,4 @@ 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

@@ -14,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
@@ -37,18 +37,18 @@ module Minitest
     include Liquid
 
     def assert_template_result(expected, template, assigns = {}, message = nil)
-      assert_equal expected, Template.parse(template, line_numbers: true).render!(assigns), message
+      assert_equal expected, Template.parse(template).render!(assigns), message
     end
 
     def assert_template_result_matches(expected, template, assigns = {}, message = nil)
-      return assert_template_result(expected, template, assigns, message) unless expected.is_a?(Regexp)
+      return assert_template_result(expected, template, assigns, message) unless expected.is_a? Regexp
 
-      assert_match expected, Template.parse(template, line_numbers: true).render!(assigns), message
+      assert_match expected, Template.parse(template).render!(assigns), message
     end
 
     def assert_match_syntax_error(match, template, assigns = {})
       exception = assert_raises(Liquid::SyntaxError) do
-        Template.parse(template, line_numbers: true).render(assigns)
+        Template.parse(template).render(assigns)
       end
       assert_match match, exception.message
     end
@@ -84,13 +84,6 @@ 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
 
@@ -121,17 +114,3 @@ 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,47 +44,10 @@ class BlockUnitTest < Minitest::Test
   end
 
   def test_with_custom_tag
-    with_custom_tag('testtag', Block) do
+    Liquid::Template.register_tag("testtag", Block)
-      assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
+    assert Liquid::Template.parse("{% testtag %} {% endtesttag %}")
-    end
+  ensure
-  end
+    Liquid::Template.tags.delete('testtag')
-
-  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
@@ -68,7 +68,7 @@ class ConditionUnitTest < Minitest::Test
     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' => 1 }, '==', { 'a' => 1 }).evaluate
     assert_equal true, Condition.new({ 'a' => 2 }, 'contains', 'a').evaluate
   end
 
@@ -107,11 +107,11 @@ class ConditionUnitTest < Minitest::Test
 
     assert_equal false, condition.evaluate
 
-    condition.or(Condition.new(2, '==', 1))
+    condition.or Condition.new(2, '==', 1)
 
     assert_equal false, condition.evaluate
 
-    condition.or(Condition.new(1, '==', 1))
+    condition.or Condition.new(1, '==', 1)
 
     assert_equal true, condition.evaluate
   end
@@ -121,22 +121,22 @@ class ConditionUnitTest < Minitest::Test
 
     assert_equal true, condition.evaluate
 
-    condition.and(Condition.new(2, '==', 2))
+    condition.and Condition.new(2, '==', 2)
 
     assert_equal true, condition.evaluate
 
-    condition.and(Condition.new(2, '==', 1))
+    condition.and Condition.new(2, '==', 1)
 
     assert_equal false, condition.evaluate
   end
 
   def test_should_allow_custom_proc_operator
-    Condition.operators['starts_with'] = proc { |_cond, left, right| left =~ /^#{right}/ }
+    Condition.operators['starts_with'] = proc { |cond, left, right| left =~ %r{^#{right}} }
 
     assert_evaluates_true 'bob', 'starts_with', 'b'
     assert_evaluates_false 'bob', 'starts_with', 'o'
   ensure
-    Condition.operators.delete('starts_with')
+    Condition.operators.delete 'starts_with'
   end
 
   def test_left_or_right_may_contain_operators

test/unit/context_unit_test.rb

@@ -206,9 +206,9 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_merge
-    @context.merge("test" => "test")
+    @context.merge({ "test" => "test" })
     assert_equal 'test', @context['test']
-    @context.merge("test" => "newvalue", "foo" => "bar")
+    @context.merge({ "test" => "newvalue", "foo" => "bar" })
     assert_equal 'newvalue', @context['test']
     assert_equal 'bar', @context['foo']
   end
@@ -235,10 +235,10 @@ class ContextUnitTest < Minitest::Test
 
   def test_hash_to_array_transition
     @context['colors'] = {
-      'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
+      'Blue'    => ['003366', '336699', '6699CC', '99CCFF'],
-      'Green' => ['003300', '336633', '669966', '99CC99'],
+      'Green'   => ['003300', '336633', '669966', '99CC99'],
-      'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
+      'Yellow'  => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
-      'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
+      'Red'     => ['660000', '993333', 'CC6666', 'FF9999']
     }
 
     assert_equal '003366', @context['colors.Blue[0]']
@@ -263,7 +263,7 @@ class ContextUnitTest < Minitest::Test
 
   def test_access_hashes_with_hash_notation
     @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
-    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
+    @context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' } ] }
 
     assert_equal 5, @context['products["count"]']
     assert_equal 'deepsnow', @context['products["tags"][0]']
@@ -301,7 +301,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_first_can_appear_in_middle_of_callchain
-    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
+    @context['product'] = { 'variants' => [ { 'title' => 'draft151cm' }, { 'title' => 'element151cm' } ] }
 
     assert_equal 'draft151cm', @context['product.variants[0].title']
     assert_equal 'element151cm', @context['product.variants[1].title']
@@ -453,7 +453,7 @@ class ContextUnitTest < Minitest::Test
   end
 
   def test_context_initialization_with_a_proc_in_environment
-    contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo)
+    contx = Context.new([test: ->(c) { c['poutine'] }], { test: :foo })
 
     assert contx
     assert_nil contx['poutine']
@@ -468,79 +468,11 @@ 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

test/unit/partial_cache_unit_test.rb

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

@@ -36,8 +36,7 @@ class StrainerUnitTest < Minitest::Test
     rescue Liquid::ArgumentError => e
       assert_match(
         /\ALiquid error: wrong number of arguments \((1 for 0|given 1, expected 0)\)\z/,
-        e.message
+        e.message)
-      )
       assert_equal e.backtrace[0].split(':')[0], __FILE__
     end
   end
@@ -136,7 +135,7 @@ class StrainerUnitTest < Minitest::Test
   end
 
   module LateAddedFilter
-    def late_added_filter(_input)
+    def late_added_filter(input)
       "filtered"
     end
   end
@@ -151,7 +150,7 @@ class StrainerUnitTest < Minitest::Test
     mod = Module.new do
       class << self
         attr_accessor :include_count
-        def included(_mod)
+        def included(mod)
           self.include_count += 1
         end
       end

test/unit/tag_unit_test.rb

@@ -18,42 +18,4 @@ 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