Tidy instance variables

Instead of needing to squash instance assigns, we instead just put them at the bottom of the enviornment stack.

This simplifies the code base and gains extra performance by not needing to loop over scopes and environments.

.gitignore

@@ -4,7 +4,6 @@
 pkg
 *.rbc
 .rvmrc
-.idea
 .ruby-version
 Gemfile.lock
 .bundle

.rubocop.yml

@@ -1,10 +1,16 @@
 inherit_from:
-  - .rubocop.shopify.yml
+  - https://shopify.github.io/ruby-style-guide/rubocop.yml
+  - .rubocop_todo.yml
 
 require: rubocop-performance
 
 Performance:
   Enabled: true
 
-Metrics/LineLength:
-  Enabled: false
+AllCops:
+  Exclude:
+    - 'vendor/bundle/**/*'
+      
+Naming/MethodName:
+  Exclude:
+    - 'example/server/liquid_servlet.rb'

.rubocop_todo.yml

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

.travis.yml

@@ -1,30 +1,30 @@
 language: ruby
+cache: bundler
 
 rvm:
   - 2.4
   - 2.5
-  - 2.6
+  - &latest_ruby 2.6
   - 2.7
   - ruby-head
   - jruby-head
   - truffleruby
 
-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
 
-install:
-  - bundle install
-
-script: bundle exec rake
+branches:
+  only:
+    - master
+    - gh-pages
+    - /.*-stable/
 
 notifications:
   disable: true

Gemfile

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 source 'https://rubygems.org'
 git_source(:github) do |repo_name|
   "https://github.com/#{repo_name}.git"
@@ -10,6 +8,7 @@ gemspec
 group :benchmark, :test do
   gem 'benchmark-ips'
   gem 'memory_profiler'
+  gem 'terminal-table'
 
   install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
     gem 'stackprof'
@@ -21,6 +20,6 @@ group :test do
   gem 'rubocop-performance', require: false
 
   platform :mri, :truffleruby do
-    gem 'liquid-c', github: 'Shopify/liquid-c', ref: '7ba926791ef8411984d0f3e41c6353fd716041c6'
+    gem 'liquid-c', github: 'Shopify/liquid-c', ref: 'master'
   end
 end

History.md

@@ -274,7 +274,7 @@ Yanked from rubygems, as it contained too many changes that broke compatibility.
 * Fixed bad error reporting when a filter called a method which doesn't exist. Liquid told you that it couldn't find the filter which was obviously misleading [Tobias Luetke]
 * Removed count helper from standard lib. use size [Tobias Luetke]
 * Fixed bug with string filter parameters failing to tolerate commas in strings. [Paul Hammond]
-* Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ARGUMENT_SEPARATOR: , by default [Paul Hammond]
+* Improved filter parameters. Filter parameters are now context sensitive; Types are resolved according to the rules of the context. Multiple parameters are now separated by the Liquid::ArgumentSeparator: , by default [Paul Hammond]
     {{ 'Typo' | link_to: 'http://typo.leetsoft.com', 'Typo - a modern weblog engine' }}
 * Added Liquid::Drop. A base class which you can use for exporting proxy objects to liquid which can acquire more data when used in liquid. [Tobias Luetke]
 

README.md

@@ -106,3 +106,9 @@ 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,11 +1,9 @@
-# frozen_string_literal: true
-
 require 'rake'
 require 'rake/testtask'
-$LOAD_PATH.unshift(File.expand_path('lib', __dir__))
-require 'liquid/version'
+$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+require "liquid/version"
 
-task(default: %i[test rubocop])
+task(default: [:test, :rubocop])
 
 desc('run test suite with default parser')
 Rake::TestTask.new(:base_test) do |t|
@@ -37,7 +35,6 @@ task :test do
   Rake::Task['base_test'].invoke
 
   if RUBY_ENGINE == 'ruby' || RUBY_ENGINE == 'truffleruby'
-
     ENV['LIQUID_C'] = '1'
 
     ENV['LIQUID_PARSER_MODE'] = 'lax'
@@ -52,7 +49,7 @@ end
 
 task(gem: :build)
 task :build do
-  system 'gem build liquid.gemspec'
+  system "gem build liquid.gemspec"
 end
 
 task install: :build do
@@ -61,45 +58,45 @@ end
 
 task release: :build do
   system "git tag -a v#{Liquid::VERSION} -m 'Tagging #{Liquid::VERSION}'"
-  system 'git push --tags'
+  system "git push --tags"
   system "gem push liquid-#{Liquid::VERSION}.gem"
   system "rm liquid-#{Liquid::VERSION}.gem"
 end
 
 namespace :benchmark do
-  desc 'Run the liquid benchmark with lax parsing'
+  desc "Run the liquid benchmark with lax parsing"
   task :run do
-    ruby './performance/benchmark.rb lax'
+    ruby "./performance/benchmark.rb lax"
   end
 
-  desc 'Run the liquid benchmark with strict parsing'
+  desc "Run the liquid benchmark with strict parsing"
   task :strict do
-    ruby './performance/benchmark.rb strict'
+    ruby "./performance/benchmark.rb strict"
   end
 end
 
 namespace :profile do
-  desc 'Run the liquid profile/performance coverage'
+  desc "Run the liquid profile/performance coverage"
   task :run do
-    ruby './performance/profile.rb'
+    ruby "./performance/profile.rb"
   end
 
-  desc 'Run the liquid profile/performance coverage with strict parsing'
+  desc "Run the liquid profile/performance coverage with strict parsing"
   task :strict do
-    ruby './performance/profile.rb strict'
+    ruby "./performance/profile.rb strict"
   end
 end
 
 namespace :memory_profile do
-  desc 'Run memory profiler'
+  desc "Run memory profiler"
   task :run do
-    ruby './performance/memory_profile.rb'
+    ruby "./performance/memory_profile.rb"
   end
 end
 
-desc('Run example')
+desc("Run example")
 task :example do
-  ruby '-w -d -Ilib example/server/server.rb'
+  ruby "-w -d -Ilib example/server/server.rb"
 end
 
 task :console do

example/server/example_servlet.rb

@@ -1,8 +1,6 @@
-# frozen_string_literal: true
-
 module ProductsFilter
   def price(integer)
-    format('$%.2d USD', integer / 100.0)
+    format("$%.2d USD", integer / 100.0)
   end
 
   def prettyprint(text)
@@ -30,17 +28,17 @@ class Servlet < LiquidServlet
   private
 
   def products_list
-    [{ 'name' => 'Arbor Draft', 'price' => 39_900, 'description' => 'the *arbor draft* is a excellent product' },
-     { 'name' => 'Arbor Element', 'price' => 40_000, 'description' => 'the *arbor element* rocks for freestyling' },
-     { 'name' => 'Arbor Diamond', 'price' => 59_900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
+    [{ 'name' => 'Arbor Draft', 'price' => 39900, 'description' => 'the *arbor draft* is a excellent product' },
+     { 'name' => 'Arbor Element', 'price' => 40000, 'description' => 'the *arbor element* rocks for freestyling' },
+     { 'name' => 'Arbor Diamond', 'price' => 59900, 'description' => 'the *arbor diamond* is a made up product because im obsessed with arbor and have no creativity' }]
   end
 
   def more_products_list
-    [{ 'name' => 'Arbor Catalyst', 'price' => 39_900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
-     { 'name' => 'Arbor Fish', 'price' => 40_000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
+    [{ 'name' => 'Arbor Catalyst', 'price' => 39900, 'description' => 'the *arbor catalyst* is an advanced drop-through for freestyle and flatground performance and versatility' },
+     { 'name' => 'Arbor Fish', 'price' => 40000, 'description' => 'the *arbor fish* is a compact pin that features an extended wheelbase and time-honored teardrop shape' }]
   end
 
   def description
-    'List of Products ~ This is a list of products with price and description.'
+    "List of Products ~ This is a list of products with price and description."
   end
 end

example/server/liquid_servlet.rb

@@ -1,17 +1,12 @@
-# frozen_string_literal: true
-
 class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
-  def get(req, res)
+  def do_GET(req, res)
     handle(:get, req, res)
   end
 
-  def post(req, res)
+  def do_POST(req, res)
     handle(:post, req, res)
   end
 
-  alias_method :do_GET, :get
-  alias_method :do_POST, :post
-
   private
 
   def handle(_type, req, res)
@@ -22,7 +17,7 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
     @action = Regexp.last_match(1) || 'index'
     @assigns = send(@action) if respond_to?(@action)
 
-    @response['Content-Type'] = 'text/html'
+    @response['Content-Type'] = "text/html"
     @response.status = 200
     @response.body = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
   end

example/server/server.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'webrick'
 require 'rexml/document'
 
@@ -10,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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # Copyright (c) 2005 Tobias Luetke
 #
 # Permission is hereby granted, free of charge, to any person obtaining
@@ -22,31 +20,31 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 module Liquid
-  FILTER_SEPARATOR = /\|/.freeze
-  ARGUMENT_SEPARATOR = ','
-  FILTER_ARGUMENT_SEPARATOR = ':'
-  VARIABLE_ATTRIBUTE_SEPARATOR = '.'
-  WHITESPACE_CONTROL = '-'
-  TAG_START = /\{\%/.freeze
-  TAG_END = /\%\}/.freeze
-  VARIABLE_SIGNATURE = /\(?[\w\-\.\[\]]\)?/.freeze
-  VARIABLE_SEGMENT = /[\w\-]/.freeze
-  VARIABLE_START = /\{\{/.freeze
-  VARIABLE_END = /\}\}/.freeze
-  VARIABLE_INCOMPLETE_END = /\}\}?/.freeze
-  QUOTED_STRING = /"[^"]*"|'[^']*'/.freeze
-  QUOTED_FRAGMENT = /#{QUOTED_STRING}|(?:[^\s,\|'"]|#{QUOTED_STRING})+/o.freeze
-  TAG_ATTRIBUTES = /(\w+)\s*\:\s*(#{QUOTED_FRAGMENT})/o.freeze
-  ANY_STARTING_TAG = /#{TAG_START}|#{VARIABLE_START}/o.freeze
-  PARTIAL_TEMPLATE_PARSER = /#{TAG_START}.*?#{TAG_END}|#{VARIABLE_START}.*?#{VARIABLE_INCOMPLETE_END}/om.freeze
-  TEMPLATE_PARSER = /(#{PARTIAL_TEMPLATE_PARSER}|#{ANY_STARTING_TAG})/om.freeze
-  VARIABLE_PARSER = /\[[^\]]+\]|#{VARIABLE_SEGMENT}+\??/o.freeze
+  FilterSeparator             = /\|/
+  ArgumentSeparator           = ','.freeze
+  FilterArgumentSeparator     = ':'.freeze
+  VariableAttributeSeparator  = '.'.freeze
+  WhitespaceControl           = '-'.freeze
+  TagStart                    = /\{\%/
+  TagEnd                      = /\%\}/
+  VariableSignature           = /\(?[\w\-\.\[\]]\)?/
+  VariableSegment             = /[\w\-]/
+  VariableStart               = /\{\{/
+  VariableEnd                 = /\}\}/
+  VariableIncompleteEnd       = /\}\}?/
+  QuotedString                = /"[^"]*"|'[^']*'/
+  QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
+  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
+  AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
+  PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
+  TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
+  VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
 
   singleton_class.send(:attr_accessor, :cache_classes)
   self.cache_classes = true
 end
 
-require 'liquid/version'
+require "liquid/version"
 require 'liquid/parse_tree_visitor'
 require 'liquid/lexer'
 require 'liquid/parser'
@@ -76,6 +74,8 @@ 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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Block < Tag
     MAX_DEPTH = 100
@@ -29,16 +27,16 @@ module Liquid
     end
 
     def unknown_tag(tag, _params, _tokens)
-      if tag == 'else'
-        raise SyntaxError, parse_context.locale.t('errors.syntax.unexpected_else',
-                                                  block_name: block_name)
-      elsif tag.start_with?('end')
-        raise SyntaxError, parse_context.locale.t('errors.syntax.invalid_delimiter',
-                                                  tag: tag,
-                                                  block_name: block_name,
-                                                  block_delimiter: block_delimiter)
+      if tag == 'else'.freeze
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else".freeze,
+          block_name: block_name)
+      elsif tag.start_with?('end'.freeze)
+        raise SyntaxError, parse_context.locale.t("errors.syntax.invalid_delimiter".freeze,
+          tag: tag,
+          block_name: block_name,
+          block_delimiter: block_delimiter)
       else
-        raise SyntaxError, parse_context.locale.t('errors.syntax.unknown_tag', tag: tag)
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag)
       end
     end
 
@@ -53,15 +51,18 @@ module Liquid
     protected
 
     def parse_body(body, tokens)
-      raise StackLevelError, 'Nesting too deep' if parse_context.depth >= MAX_DEPTH
-
+      if parse_context.depth >= MAX_DEPTH
+        raise StackLevelError, "Nesting too deep".freeze
+      end
       parse_context.depth += 1
       begin
         body.parse(tokens, parse_context) do |end_tag_name, end_tag_params|
           @blank &&= body.blank?
 
           return false if end_tag_name == block_delimiter
-          raise SyntaxError, parse_context.locale.t('errors.syntax.tag_never_closed', block_name: block_name) unless end_tag_name
+          unless end_tag_name
+            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)
+          end
 
           # this tag is not registered with the system
           # pass it to the current block for special handling or error reporting

lib/liquid/block_body.rb

@@ -1,12 +1,11 @@
-# frozen_string_literal: true
-
 module Liquid
   class BlockBody
-    FULL_TOKEN = /\A#{TAG_START}#{WHITESPACE_CONTROL}?\s*(\w+)\s*(.*?)#{WHITESPACE_CONTROL}?#{TAG_END}\z/om.freeze
-    CONTENT_OF_VARIABLE = /\A#{VARIABLE_START}#{WHITESPACE_CONTROL}?(.*?)#{WHITESPACE_CONTROL}?#{VARIABLE_END}\z/om.freeze
-    WHITESPACE_OR_NOTHING = /\A\s*\z/.freeze
-    TAG_START = '{%'
-    VAR_START = '{{'
+    LiquidTagToken = /\A\s*(\w+)\s*(.*?)\z/o
+    FullToken = /\A#{TagStart}#{WhitespaceControl}?(\s*)(\w+)(\s*)(.*?)#{WhitespaceControl}?#{TagEnd}\z/om
+    ContentOfVariable = /\A#{VariableStart}#{WhitespaceControl}?(.*?)#{WhitespaceControl}?#{VariableEnd}\z/om
+    WhitespaceOrNothing = /\A\s*\z/
+    TAGSTART = "{%".freeze
+    VARSTART = "{{".freeze
 
     attr_reader :nodelist
 
@@ -15,36 +14,83 @@ module Liquid
       @blank = true
     end
 
-    def parse(tokenizer, parse_context)
+    def parse(tokenizer, parse_context, &block)
       parse_context.line_number = tokenizer.line_number
-      while (token = tokenizer.shift)
-        next if token.empty?
 
-        case
-        when token.start_with?(TAG_START)
-          whitespace_handler(token, parse_context)
-          raise_missing_tag_terminator(token, parse_context) unless token =~ FULL_TOKEN
+      if tokenizer.for_liquid_tag
+        parse_for_liquid_tag(tokenizer, parse_context, &block)
+      else
+        parse_for_document(tokenizer, parse_context, &block)
+      end
+    end
+
+    private def parse_for_liquid_tag(tokenizer, parse_context)
+      while token = tokenizer.shift
+        unless token.empty? || token =~ WhitespaceOrNothing
+          unless token =~ LiquidTagToken
+            # line isn't empty but didn't match tag syntax, yield and let the
+            # caller raise a syntax error
+            return yield token, token
+          end
           tag_name = Regexp.last_match(1)
           markup = Regexp.last_match(2)
-          # fetch the tag from registered blocks
-          unless (tag = registered_tags[tag_name])
+          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?(VAR_START)
+        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
-          token.lstrip! if parse_context.trim_whitespace
+          if parse_context.trim_whitespace
+            token.lstrip!
+          end
           parse_context.trim_whitespace = false
           @nodelist << token
-          @blank &&= token.match?(WHITESPACE_OR_NOTHING)
+          @blank &&= !!(token =~ WhitespaceOrNothing)
         end
         parse_context.line_number = tokenizer.line_number
       end
@@ -53,11 +99,13 @@ module Liquid
     end
 
     def whitespace_handler(token, parse_context)
-      if token[2] == WHITESPACE_CONTROL
+      if token[2] == WhitespaceControl
         previous_token = @nodelist.last
-        previous_token.rstrip! if previous_token.is_a?(String)
+        if previous_token.is_a?(String)
+          previous_token.rstrip!
+        end
       end
-      parse_context.trim_whitespace = (token[-3] == WHITESPACE_CONTROL)
+      parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
     end
 
     def blank?
@@ -65,14 +113,14 @@ module Liquid
     end
 
     def render(context)
-      render_to_output_buffer(context, +'')
+      render_to_output_buffer(context, '')
     end
 
     def render_to_output_buffer(context, output)
       context.resource_limits.render_score += @nodelist.length
 
       idx = 0
-      while (node = @nodelist[idx])
+      while node = @nodelist[idx]
         previous_output_size = output.bytesize
 
         case node
@@ -81,7 +129,7 @@ module Liquid
         when Variable
           render_node(context, output, node)
         when Block
-          render_node(context, node.blank? ? +'' : output, node)
+          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
@@ -115,12 +163,11 @@ module Liquid
     def raise_if_resource_limits_reached(context, length)
       context.resource_limits.render_length += length
       return unless context.resource_limits.reached?
-
-      raise MemoryError, 'Memory limits exceeded'
+      raise MemoryError, "Memory limits exceeded".freeze
     end
 
     def create_variable(token, parse_context)
-      token.scan(CONTENT_OF_VARIABLE) do |content|
+      token.scan(ContentOfVariable) do |content|
         markup = content.first
         return Variable.new(markup, parse_context)
       end
@@ -128,11 +175,11 @@ module Liquid
     end
 
     def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t('errors.syntax.tag_termination', token: token, tag_end: TAG_END.inspect)
+      raise SyntaxError, 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', token: token, tag_end: VARIABLE_END.inspect)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination".freeze, token: token, tag_end: VariableEnd.inspect)
     end
 
     def registered_tags

lib/liquid/condition.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Container for liquid nodes which conveniently wraps decision making logic
   #
@@ -9,15 +7,15 @@ module Liquid
   #   c.evaluate #=> true
   #
   class Condition #:nodoc:
-    @operators = {
-      '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
-      '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<>' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
-      '<' => :<,
-      '>' => :>,
-      '>=' => :>=,
-      '<=' => :<=,
-      'contains' => lambda do |_cond, left, right|
+    @@operators = {
+      '=='.freeze => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
+      '!='.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<>'.freeze => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
+      '<'.freeze => :<,
+      '>'.freeze => :>,
+      '>='.freeze => :>=,
+      '<='.freeze => :<=,
+      'contains'.freeze => lambda do |_cond, left, right|
         if left && right && left.respond_to?(:include?)
           right = right.to_s if left.is_a?(String)
           left.include?(right)
@@ -27,8 +25,8 @@ module Liquid
       end,
     }
 
-    class << self
-      attr_accessor :operators
+    def self.operators
+      @@operators
     end
 
     attr_reader :attachment, :child_condition
@@ -80,7 +78,7 @@ module Liquid
     end
 
     def inspect
-      "#<Condition #{[@left, @operator, @right].compact.join(' ')}>"
+      "#<Condition #{[@left, @operator, @right].compact.join(' '.freeze)}>"
     end
 
     protected

lib/liquid/context.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Context keeps the variable stack and resolves variables, as well as keywords
   #
@@ -14,28 +12,35 @@ module Liquid
   #
   #   context['bob']  #=> nil  class Context
   class Context
-    attr_reader :scopes, :errors, :registers, :environments, :resource_limits
+    attr_reader :scopes, :errors, :registers, :environments, :resource_limits, :static_registers, :static_environments
     attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
-    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil)
-      @environments     = [environments].flatten
-      @scopes           = [(outer_scope || {})]
-      @registers        = registers
-      @errors           = []
-      @partial          = false
-      @strict_variables = false
-      @resource_limits  = resource_limits || ResourceLimits.new(Template.default_resource_limits)
-      squash_instance_assigns_with_environments
+    # rubocop:disable Metrics/ParameterLists
+    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_registers: {}, static_environments: {})
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_registers, static_environments)
+    end
 
-      @this_stack_used = false
+    def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_registers = {}, static_environments = {})
+      @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
-      self.exception_renderer = ->(_e) { raise } if rethrow_errors
-
-      @interrupts = []
-      @filters = []
-      @global_filter = nil
+      if rethrow_errors
+        self.exception_renderer = ->(_e) { raise }
+      end
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def warnings
       @warnings ||= []
@@ -89,7 +94,7 @@ module Liquid
     # Push new local scope on the stack. use <tt>Context#stack</tt> instead
     def push(new_scope = {})
       @scopes.unshift(new_scope)
-      raise StackLevelError, 'Nesting too deep' if @scopes.length > Block::MAX_DEPTH
+      check_overflow
     end
 
     # Merge a hash of variables in the current local scope
@@ -100,7 +105,6 @@ module Liquid
     # Pop from the stack. use <tt>Context#stack</tt> instead
     def pop
       raise ContextError if @scopes.size == 1
-
       @scopes.shift
     end
 
@@ -112,19 +116,30 @@ module Liquid
     #   end
     #
     #   context['var]  #=> nil
-    def stack(new_scope = nil)
-      old_stack_used = @this_stack_used
-      if new_scope
-        push(new_scope)
-        @this_stack_used = true
-      else
-        @this_stack_used = false
-      end
-
+    def stack(new_scope = {})
+      push(new_scope)
       yield
     ensure
-      pop if @this_stack_used
-      @this_stack_used = old_stack_used
+      pop
+    end
+
+    # Creates a new context inheriting resource limits, filters, environment etc.,
+    # but with an isolated scope.
+    def new_isolated_subcontext
+      check_overflow
+
+      Context.build(
+        resource_limits: resource_limits,
+        static_environments: static_environments,
+        static_registers: static_registers
+      ).tap do |subcontext|
+        subcontext.base_scope_depth = base_scope_depth + 1
+        subcontext.exception_renderer = exception_renderer
+        subcontext.filters = @filters
+        subcontext.strainer = nil
+        subcontext.errors = errors
+        subcontext.warnings = warnings
+      end
     end
 
     def clear_instance_assigns
@@ -133,10 +148,6 @@ 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
 
@@ -165,25 +176,13 @@ 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 = nil
-
-      if scope.nil?
-        @environments.each do |e|
-          variable = lookup_and_evaluate(e, key, raise_on_not_found: raise_on_not_found)
-          # When lookup returned a value OR there is no value but the lookup also did not raise
-          # then it is the value we are looking for.
-          if !variable.nil? || @strict_variables && raise_on_not_found
-            scope = e
-            break
-          end
-        end
+      variable = if index
+        lookup_and_evaluate(@scopes[index], key, raise_on_not_found: raise_on_not_found)
+      else
+        try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
       end
 
-      scope ||= @environments.last || @scopes.last
-      variable ||= lookup_and_evaluate(scope, key, raise_on_not_found: raise_on_not_found)
-
       variable = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
@@ -191,7 +190,9 @@ module Liquid
     end
 
     def lookup_and_evaluate(obj, key, raise_on_not_found: true)
-      raise Liquid::UndefinedVariable, "undefined variable #{key}" if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
+      if @strict_variables && raise_on_not_found && obj.respond_to?(:key?) && !obj.key?(key)
+        raise Liquid::UndefinedVariable, "undefined variable #{key}"
+      end
 
       value = obj[key]
 
@@ -202,24 +203,43 @@ module Liquid
       end
     end
 
+    protected
+
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
+
     private
 
+    attr_reader :base_scope_depth
+
+    def try_variable_find_in_environments(key, raise_on_not_found:)
+      @environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+      end
+      @static_environments.each do |environment|
+        found_variable = lookup_and_evaluate(environment, key, raise_on_not_found: raise_on_not_found)
+        if !found_variable.nil? || @strict_variables && raise_on_not_found
+          return found_variable
+        end
+      end
+      nil
+    end
+
+    def check_overflow
+      raise StackLevelError, "Nesting too deep".freeze if overflow?
+    end
+
+    def overflow?
+      base_scope_depth + @scopes.length > Block::MAX_DEPTH
+    end
+
     def internal_error
       # raise and catch to set backtrace and cause on exception
       raise Liquid::InternalError, 'internal'
-    rescue Liquid::InternalError => e
-      e
+    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

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Document < BlockBody
     def self.parse(tokens, parse_context)
@@ -19,10 +17,10 @@ module Liquid
 
     def unknown_tag(tag, parse_context)
       case tag
-      when 'else', 'end'
-        raise SyntaxError, parse_context.locale.t('errors.syntax.unexpected_outer_tag', tag: tag)
+      when 'else'.freeze, 'end'.freeze
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag".freeze, tag: tag)
       else
-        raise SyntaxError, parse_context.locale.t('errors.syntax.unknown_tag', tag: tag)
+        raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag".freeze, tag: tag)
       end
     end
   end

lib/liquid/drop.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'set'
 
 module Liquid
@@ -28,7 +26,6 @@ module Liquid
     # Catch all for the method
     def liquid_method_missing(method)
       return nil unless @context&.strict_variables
-
       raise Liquid::UndefinedDropMethod, "undefined method #{method}"
     end
 
@@ -70,7 +67,7 @@ module Liquid
 
         if include?(Enumerable)
           blacklist += Enumerable.public_instance_methods
-          blacklist -= %i[sort count first min max include?]
+          blacklist -= [:sort, :count, :first, :min, :max, :include?]
         end
 
         whitelist = [:to_liquid] + (public_instance_methods - blacklist)

lib/liquid/errors.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Error < ::StandardError
     attr_accessor :line_number
@@ -7,12 +5,12 @@ module Liquid
     attr_accessor :markup_context
 
     def to_s(with_prefix = true)
-      str = +''
+      str = ""
       str << message_prefix if with_prefix
       str << super()
 
       if markup_context
-        str << ' '
+        str << " "
         str << markup_context
       end
 
@@ -22,20 +20,20 @@ module Liquid
     private
 
     def message_prefix
-      str = +''
+      str = ""
       str << if is_a?(SyntaxError)
-        'Liquid syntax error'
+        "Liquid syntax error"
       else
-        'Liquid error'
+        "Liquid error"
       end
 
       if line_number
-        str << ' ('
-        str << template_name << ' ' if template_name
-        str << 'line ' << line_number.to_s << ')'
+        str << " ("
+        str << template_name << " " if template_name
+        str << "line " << line_number.to_s << ")"
       end
 
-      str << ': '
+      str << ": "
       str
     end
   end

lib/liquid/expression.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Expression
     class MethodLiteral
@@ -16,18 +14,18 @@ module Liquid
     end
 
     LITERALS = {
-      nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
-      'true' => true,
-      'false' => false,
-      'blank' => MethodLiteral.new(:blank?, '').freeze,
-      'empty' => MethodLiteral.new(:empty?, '').freeze
+      nil => nil, 'nil'.freeze => nil, 'null'.freeze => nil, ''.freeze => nil,
+      'true'.freeze => true,
+      'false'.freeze => false,
+      'blank'.freeze => MethodLiteral.new(:blank?, '').freeze,
+      'empty'.freeze => MethodLiteral.new(:empty?, '').freeze
     }.freeze
 
-    SINGLE_QUOTED_STRING = /\A'(.*)'\z/m.freeze
-    DOUBLE_QUOTED_STRING = /\A"(.*)"\z/m.freeze
-    INTEGERS_REGEX       = /\A(-?\d+)\z/.freeze
-    FLOATS_REGEX         = /\A(-?\d[\d\.]+)\z/.freeze
-    RANGES_REGEX         = /\A\((\S+)\.\.(\S+)\)\z/.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)

lib/liquid/extensions.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'time'
 require 'date'
 

lib/liquid/file_system.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # A Liquid file system is a way to let your templates retrieve other templates for use with the include tag.
   #
@@ -17,7 +15,7 @@ module Liquid
   class BlankFileSystem
     # Called by Liquid to retrieve a template file
     def read_template_file(_template_path)
-      raise FileSystemError, 'This liquid context does not allow includes.'
+      raise FileSystemError, "This liquid context does not allow includes."
     end
   end
 
@@ -46,7 +44,7 @@ module Liquid
   class LocalFileSystem
     attr_accessor :root
 
-    def initialize(root, pattern = '_%s.liquid')
+    def initialize(root, pattern = "_%s.liquid".freeze)
       @root = root
       @pattern = pattern
     end
@@ -61,7 +59,7 @@ module Liquid
     def full_path(template_path)
       raise FileSystemError, "Illegal template name '#{template_path}'" unless template_path =~ %r{\A[^./][a-zA-Z0-9_/]+\z}
 
-      full_path = if template_path.include?('/')
+      full_path = if template_path.include?('/'.freeze)
         File.join(root, File.dirname(template_path), @pattern % File.basename(template_path))
       else
         File.join(root, @pattern % template_path)

lib/liquid/forloop_drop.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class ForloopDrop < Drop
     def initialize(name, length, parentloop)

lib/liquid/i18n.rb

@@ -1,10 +1,8 @@
-# frozen_string_literal: true
-
 require 'yaml'
 
 module Liquid
   class I18n
-    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), 'locales', 'en.yml')
+    DEFAULT_LOCALE = File.join(File.expand_path(__dir__), "locales", "en.yml")
 
     TranslationError = Class.new(StandardError)
 
@@ -33,7 +31,7 @@ module Liquid
     end
 
     def deep_fetch_translation(name)
-      name.split('.').reduce(locale) do |level, cur|
+      name.split('.'.freeze).reduce(locale) do |level, cur|
         level[cur] || raise(TranslationError, "Translation for #{name} does not exist in locale #{path}")
       end
     end

lib/liquid/interrupts.rb

@@ -1,18 +1,16 @@
-# frozen_string_literal: true
-
 module Liquid
   # An interrupt is any command that breaks processing of a block (ex: a for loop).
   class Interrupt
     attr_reader :message
 
     def initialize(message = nil)
-      @message = message || 'interrupt'
+      @message = message || "interrupt".freeze
     end
   end
 
   # Interrupt that is thrown whenever a {% break %} is called.
-  class BreakInterrupt < RuntimeError; end
+  class BreakInterrupt < Interrupt; end
 
   # Interrupt that is thrown whenever a {% continue %} is called.
-  class ContinueInterrupt < RuntimeError; end
+  class ContinueInterrupt < Interrupt; end
 end

lib/liquid/legacy.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-module Liquid
-  FilterSeparator = FILTER_SEPARATOR
-  ArgumentSeparator = ARGUMENT_SEPARATOR
-  FilterArgumentSeparator = FILTER_ARGUMENT_SEPARATOR
-  VariableAttributeSeparator = VARIABLE_ATTRIBUTE_SEPARATOR
-  WhitespaceControl = WHITESPACE_CONTROL
-  TagStart = TAG_START
-  TagEnd = TAG_END
-  VariableSignature = VARIABLE_SIGNATURE
-  VariableSegment = VARIABLE_SEGMENT
-  VariableStart = VARIABLE_START
-  VariableEnd = VARIABLE_END
-  VariableIncompleteEnd = VARIABLE_INCOMPLETE_END
-  QuotedString = QUOTED_STRING
-  QuotedFragment = QUOTED_FRAGMENT
-  TagAttributes = TAG_ATTRIBUTES
-  AnyStartingTag = ANY_STARTING_TAG
-  PartialTemplateParser = PARTIAL_TEMPLATE_PARSER
-  TemplateParser = TEMPLATE_PARSER
-  VariableParser = VARIABLE_PARSER
-
-  class BlockBody
-    FullToken = FULL_TOKEN
-    ContentOfVariable = CONTENT_OF_VARIABLE
-    WhitespaceOrNothing = WHITESPACE_OR_NOTHING
-    TAGSTART = TAG_START
-    VARSTART = VAR_START
-  end
-
-  class Assign < Tag
-    Syntax = SYNTAX
-  end
-
-  class Capture < Block
-    Syntax = SYNTAX
-  end
-
-  class Case < Block
-    Syntax     = SYNTAX
-    WhenSyntax = WHEN_SYNTAX
-  end
-
-  class Cycle < Tag
-    SimpleSyntax = SIMPLE_SYNTAX
-    NamedSyntax  = NAMED_SYNTAX
-  end
-
-  class For < Block
-    Syntax = SYNTAX
-  end
-
-  class If < Block
-    Syntax = SYNTAX
-    ExpressionsAndOperators = EXPRESSIONS_AND_OPERATORS
-  end
-
-  class Include < Tag
-    Syntax = SYNTAX
-  end
-
-  class Raw < Block
-    Syntax = SYNTAX
-    FullTokenPossiblyInvalid = FULL_TOKEN_POSSIBLY_INVALID
-  end
-
-  class TableRow < Block
-    Syntax = SYNTAX
-  end
-
-  class Variable
-    FilterMarkupRegex = FILTER_MARKUP_REGEX
-    FilterParser = FILTER_PARSER
-    FilterArgsRegex = FILTER_ARGS_REGEX
-    JustTagAttributes = JUST_TAG_ATTRIBUTES
-    MarkupWithQuotedFragment = MARKUP_WITH_QUOTED_FRAGMENT
-  end
-end

lib/liquid/lexer.rb

@@ -1,27 +1,25 @@
-# frozen_string_literal: true
-
-require 'strscan'
+require "strscan"
 module Liquid
   class Lexer
     SPECIALS = {
-      '|' => :pipe,
-      '.' => :dot,
-      ':' => :colon,
-      ',' => :comma,
-      '[' => :open_square,
-      ']' => :close_square,
-      '(' => :open_round,
-      ')' => :close_round,
-      '?' => :question,
-      '-' => :dash,
+      '|'.freeze => :pipe,
+      '.'.freeze => :dot,
+      ':'.freeze => :colon,
+      ','.freeze => :comma,
+      '['.freeze => :open_square,
+      ']'.freeze => :close_square,
+      '('.freeze => :open_round,
+      ')'.freeze => :close_round,
+      '?'.freeze => :question,
+      '-'.freeze => :dash,
     }.freeze
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/.freeze
-    SINGLE_STRING_LITERAL = /'[^\']*'/.freeze
-    DOUBLE_STRING_LITERAL = /"[^\"]*"/.freeze
-    NUMBER_LITERAL = /-?\d+(\.\d+)?/.freeze
-    DOTDOT = /\.\./.freeze
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/.freeze
-    WHITESPACE_OR_NOTHING = /\s*/.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)
@@ -33,16 +31,15 @@ module Liquid
       until @ss.eos?
         @ss.skip(WHITESPACE_OR_NOTHING)
         break if @ss.eos?
-
-        tok = if (t = @ss.scan(COMPARISON_OPERATOR)) then [:comparison, t]
-        elsif (t = @ss.scan(SINGLE_STRING_LITERAL)) then [:string, t]
-        elsif (t = @ss.scan(DOUBLE_STRING_LITERAL)) then [:string, t]
-        elsif (t = @ss.scan(NUMBER_LITERAL)) then [:number, t]
-        elsif (t = @ss.scan(IDENTIFIER)) then [:id, t]
-        elsif (t = @ss.scan(DOTDOT)) then [:dotdot, t]
+        tok = if t = @ss.scan(COMPARISON_OPERATOR) then [:comparison, t]
+        elsif t = @ss.scan(SINGLE_STRING_LITERAL) then [:string, t]
+        elsif t = @ss.scan(DOUBLE_STRING_LITERAL) then [:string, t]
+        elsif t = @ss.scan(NUMBER_LITERAL) then [:number, t]
+        elsif t = @ss.scan(IDENTIFIER) then [:id, t]
+        elsif t = @ss.scan(DOTDOT) then [:dotdot, t]
         else
           c = @ss.getch
-          if (s = SPECIALS[c])
+          if s = SPECIALS[c]
             [s, c]
           else
             raise SyntaxError, "Unexpected character #{c}"

lib/liquid/locales/en.yml

@@ -22,5 +22,6 @@
       tag_never_closed: "'%{block_name}' tag was never closed"
       meta_syntax_error: "Liquid syntax error: #{e.message}"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
+      render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:
       include: "Argument error in tag 'include' - Illegal template name"

lib/liquid/parse_context.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class ParseContext
     attr_accessor :locale, :line_number, :trim_whitespace, :depth
@@ -21,6 +19,7 @@ module Liquid
       @partial = value
       @options = value ? partial_options : @template_options
       @error_mode = @options[:error_mode] || Template.error_mode
+      value
     end
 
     def partial_options

lib/liquid/parser.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Parser
     def initialize(input)
@@ -14,8 +12,9 @@ module Liquid
 
     def consume(type = nil)
       token = @tokens[@p]
-      raise SyntaxError, "Expected #{type} but found #{@tokens[@p].first}" if type && token[0] != type
-
+      if type && token[0] != type
+        raise SyntaxError, "Expected #{type} but found #{@tokens[@p].first}"
+      end
       @p += 1
       token[1]
     end
@@ -26,7 +25,6 @@ module Liquid
     def consume?(type)
       token = @tokens[@p]
       return false unless token && token[0] == type
-
       @p += 1
       token[1]
     end
@@ -36,7 +34,6 @@ module Liquid
       token = @tokens[@p]
       return false unless token && token[0] == :id
       return false unless token[1] == str
-
       @p += 1
       token[1]
     end
@@ -44,11 +41,10 @@ module Liquid
     def look(type, ahead = 0)
       tok = @tokens[@p + ahead]
       return false unless tok
-
       tok[0] == type
     end
 
-    SINGLE_TOKEN_EXPRESSION_TYPES = %i[string number].freeze
+    SINGLE_TOKEN_EXPRESSION_TYPES = [:string, :number].freeze
     private_constant :SINGLE_TOKEN_EXPRESSION_TYPES
 
     def expression
@@ -70,9 +66,11 @@ module Liquid
     end
 
     def argument
-      str = +''
+      str = ""
       # might be a keyword argument (identifier: expression)
-      str << consume << consume << ' ' if look(:id) && look(:colon, 1)
+      if look(:id) && look(:colon, 1)
+        str << consume << consume << ' '.freeze
+      end
 
       str << expression
       str

lib/liquid/parser_switching.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   module ParserSwitching
     def parse_with_selected_parser(markup)

lib/liquid/partial_cache.rb

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

lib/liquid/profiler.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'liquid/profiler/hooks'
 
 module Liquid
@@ -99,9 +97,9 @@ module Liquid
     end
 
     def initialize
-      @partial_stack = ['<root>']
+      @partial_stack = ["<root>"]
 
-      @root_timing = Timing.new('', current_partial)
+      @root_timing = Timing.new("", current_partial)
       @timing_stack = [@root_timing]
 
       @render_start_at = Time.now

lib/liquid/profiler/hooks.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class BlockBody
     def render_node_with_profiling(context, output, node)

lib/liquid/range_lookup.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class RangeLookup
     def self.parse(start_markup, end_markup)

lib/liquid/resource_limits.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
   class ResourceLimits
     attr_accessor :render_length, :render_score, :assign_score,
-                  :render_length_limit, :render_score_limit, :assign_score_limit
+      :render_length_limit, :render_score_limit, :assign_score_limit
 
     def initialize(limits)
       @render_length_limit = limits[:render_length_limit]

lib/liquid/standardfilters.rb

@@ -1,24 +1,22 @@
-# frozen_string_literal: true
-
 require 'cgi'
 require 'bigdecimal'
 
 module Liquid
   module StandardFilters
     HTML_ESCAPE = {
-      '&' => '&',
-      '>' => '>',
-      '<' => '&lt;',
-      '"' => '&quot;',
-      "'" => '&#39;',
+      '&'.freeze => '&amp;'.freeze,
+      '>'.freeze => '&gt;'.freeze,
+      '<'.freeze => '&lt;'.freeze,
+      '"'.freeze => '&quot;'.freeze,
+      "'".freeze => '&#39;'.freeze,
     }.freeze
-    HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/.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.freeze
+    STRIP_HTML_TAGS = /<.*?>/m
 
     # Return the size of an array or of an string
     def size(input)
@@ -74,9 +72,8 @@ module Liquid
     end
 
     # Truncate a string down to x characters
-    def truncate(input, length = 50, truncate_string = '...')
+    def truncate(input, length = 50, truncate_string = "...".freeze)
       return if input.nil?
-
       input_str = input.to_s
       length = Utils.to_integer(length)
       truncate_string_str = truncate_string.to_s
@@ -85,14 +82,13 @@ module Liquid
       input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
     end
 
-    def truncatewords(input, words = 15, truncate_string = '...')
+    def truncatewords(input, words = 15, truncate_string = "...".freeze)
       return if input.nil?
-
       wordlist = input.to_s.split
       words = Utils.to_integer(words)
       l = words - 1
       l = 0 if l < 0
-      wordlist.length > l ? wordlist[0..l].join(' ').concat(truncate_string.to_s) : input
+      wordlist.length > l ? wordlist[0..l].join(" ".freeze).concat(truncate_string.to_s) : input
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -117,7 +113,7 @@ module Liquid
     end
 
     def strip_html(input)
-      empty = ''
+      empty = ''.freeze
       result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
       result.gsub!(STRIP_HTML_TAGS, empty)
       result
@@ -125,11 +121,11 @@ module Liquid
 
     # Remove all newlines from the string
     def strip_newlines(input)
-      input.to_s.gsub(/\r?\n/, '')
+      input.to_s.gsub(/\r?\n/, ''.freeze)
     end
 
     # Join elements of the array with certain character between them
-    def join(input, glue = ' ')
+    def join(input, glue = ' '.freeze)
       InputIterator.new(input).join(glue)
     end
 
@@ -224,7 +220,7 @@ module Liquid
       InputIterator.new(input).map do |e|
         e = e.call if e.is_a?(Proc)
 
-        if property == 'to_liquid'
+        if property == "to_liquid".freeze
           e
         elsif e.respond_to?(:[])
           r = e[property]
@@ -254,23 +250,23 @@ module Liquid
     end
 
     # Replace occurrences of a string with another
-    def replace(input, string, replacement = '')
+    def replace(input, string, replacement = ''.freeze)
       input.to_s.gsub(string.to_s, replacement.to_s)
     end
 
     # Replace the first occurrences of a string with another
-    def replace_first(input, string, replacement = '')
+    def replace_first(input, string, replacement = ''.freeze)
       input.to_s.sub(string.to_s, replacement.to_s)
     end
 
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string.to_s, '')
+      input.to_s.gsub(string.to_s, ''.freeze)
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string.to_s, '')
+      input.to_s.sub(string.to_s, ''.freeze)
     end
 
     # add one string to another
@@ -279,8 +275,9 @@ module Liquid
     end
 
     def concat(input, array)
-      raise ArgumentError, 'concat filter requires an array argument' unless array.respond_to?(:to_ary)
-
+      unless array.respond_to?(:to_ary)
+        raise ArgumentError, "concat filter requires an array argument"
+      end
       InputIterator.new(input).concat(array)
     end
 
@@ -291,7 +288,7 @@ module Liquid
 
     # Add <br /> tags in front of all newlines in input string
     def newline_to_br(input)
-      input.to_s.gsub(/\n/, "<br />\n")
+      input.to_s.gsub(/\n/, "<br />\n".freeze)
     end
 
     # Reformat a date using Ruby's core Time#strftime( string ) -> string
@@ -328,7 +325,7 @@ module Liquid
     def date(input, format)
       return input if format.to_s.empty?
 
-      return input unless (date = Utils.to_date(input))
+      return input unless date = Utils.to_date(input)
 
       date.strftime(format.to_s)
     end
@@ -422,8 +419,9 @@ module Liquid
       result.is_a?(BigDecimal) ? result.to_f : result
     end
 
-    def default(input, default_value = '')
+    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

lib/liquid/strainer.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'set'
 
 module Liquid
@@ -9,12 +7,12 @@ module Liquid
   # The Strainer only allows method calls defined in filters given to it via Strainer.global_filter,
   # Context#add_filters or Template.register_filter
   class Strainer #:nodoc:
-    @global_strainer = Class.new(Strainer) do
+    @@global_strainer = Class.new(Strainer) do
       @filter_methods = Set.new
     end
-    @strainer_class_cache = Hash.new do |hash, filters|
-      hash[filters] = Class.new(@global_strainer) do
-        @filter_methods = Strainer.global_strainer.filter_methods.dup
+    @@strainer_class_cache = Hash.new do |hash, filters|
+      hash[filters] = Class.new(@@global_strainer) do
+        @filter_methods = @@global_strainer.filter_methods.dup
         filters.each { |f| add_filter(f) }
       end
     end
@@ -24,13 +22,11 @@ module Liquid
     end
 
     class << self
-      attr_accessor :strainer_class_cache, :global_strainer
       attr_reader :filter_methods
     end
 
     def self.add_filter(filter)
       raise ArgumentError, "Expected module but got: #{filter.class}" unless filter.is_a?(Module)
-
       unless include?(filter)
         invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
         if invokable_non_public_methods.any?
@@ -43,8 +39,8 @@ module Liquid
     end
 
     def self.global_filter(filter)
-      @strainer_class_cache.clear
-      @global_strainer.add_filter(filter)
+      @@strainer_class_cache.clear
+      @@global_strainer.add_filter(filter)
     end
 
     def self.invokable?(method)
@@ -52,7 +48,7 @@ module Liquid
     end
 
     def self.create(context, filters = [])
-      @strainer_class_cache[filters].new(context)
+      @@strainer_class_cache[filters].new(context)
     end
 
     def invoke(method, *args)

lib/liquid/tablerowloop_drop.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class TablerowloopDrop < Drop
     def initialize(length, cols)

lib/liquid/tag.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   class Tag
     attr_reader :nodelist, :tag_name, :line_number, :parse_context
@@ -7,8 +5,8 @@ module Liquid
     include ParserSwitching
 
     class << self
-      def parse(tag_name, markup, tokenizer, options)
-        tag = new(tag_name, markup, options)
+      def parse(tag_name, markup, tokenizer, parse_context)
+        tag = new(tag_name, markup, parse_context)
         tag.parse(tokenizer)
         tag
       end
@@ -23,7 +21,8 @@ module Liquid
       @line_number = parse_context.line_number
     end
 
-    def parse(_tokens); end
+    def parse(_tokens)
+    end
 
     def raw
       "#{@tag_name} #{@markup}"
@@ -34,7 +33,7 @@ module Liquid
     end
 
     def render(_context)
-      ''
+      ''.freeze
     end
 
     # For backwards compatibility with custom tags. In a future release, the semantics

lib/liquid/tags/assign.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Assign sets a variable in your template.
   #
@@ -10,17 +8,21 @@ module Liquid
   #  {{ foo }}
   #
   class Assign < Tag
-    SYNTAX = /(#{VARIABLE_SIGNATURE}+)\s*=\s*(.*)\s*/om.freeze
+    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
+      if markup =~ Syntax
         @to = Regexp.last_match(1)
         @from = Variable.new(Regexp.last_match(2), options)
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.assign')
+        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
       end
     end
 
@@ -57,5 +59,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('assign', Assign)
+  Template.register_tag('assign'.freeze, Assign)
 end

lib/liquid/tags/break.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Break tag to be used to break out of a for loop.
   #
@@ -16,5 +14,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('break', Break)
+  Template.register_tag('break'.freeze, Break)
 end

lib/liquid/tags/capture.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Capture stores the result of a block into a variable without rendering it inplace.
   #
@@ -13,14 +11,14 @@ module Liquid
   # in a sidebar or footer.
   #
   class Capture < Block
-    SYNTAX = /(#{VARIABLE_SIGNATURE}+)/o.freeze
+    Syntax = /(#{VariableSignature}+)/o
 
     def initialize(tag_name, markup, options)
       super
-      if markup =~ SYNTAX
+      if markup =~ Syntax
         @to = Regexp.last_match(1)
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.capture')
+        raise SyntaxError, options[:locale].t("errors.syntax.capture")
       end
     end
 
@@ -37,5 +35,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('capture', Capture)
+  Template.register_tag('capture'.freeze, Capture)
 end

lib/liquid/tags/case.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
   class Case < Block
-    SYNTAX = /(#{QUOTED_FRAGMENT})/o.freeze
-    WHEN_SYNTAX = /(#{QUOTED_FRAGMENT})(?:(?:\s+or\s+|\s*\,\s*)(#{QUOTED_FRAGMENT}.*))?/om.freeze
+    Syntax     = /(#{QuotedFragment})/o
+    WhenSyntax = /(#{QuotedFragment})(?:(?:\s+or\s+|\s*\,\s*)(#{QuotedFragment}.*))?/om
 
     attr_reader :blocks, :left
 
@@ -11,10 +9,10 @@ module Liquid
       super
       @blocks = []
 
-      if markup =~ SYNTAX
+      if markup =~ Syntax
         @left = Expression.parse(Regexp.last_match(1))
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.case')
+        raise SyntaxError, options[:locale].t("errors.syntax.case".freeze)
       end
     end
 
@@ -29,9 +27,9 @@ module Liquid
 
     def unknown_tag(tag, markup, tokens)
       case tag
-      when 'when'
+      when 'when'.freeze
         record_when_condition(markup)
-      when 'else'
+      when 'else'.freeze
         record_else_condition(markup)
       else
         super
@@ -39,16 +37,14 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      context.stack do
-        execute_else_block = true
+      execute_else_block = true
 
-        @blocks.each do |block|
-          if block.else?
-            block.attachment.render_to_output_buffer(context, output) if execute_else_block
-          elsif block.evaluate(context)
-            execute_else_block = false
-            block.attachment.render_to_output_buffer(context, output)
-          end
+      @blocks.each do |block|
+        if block.else?
+          block.attachment.render_to_output_buffer(context, output) if execute_else_block
+        elsif block.evaluate(context)
+          execute_else_block = false
+          block.attachment.render_to_output_buffer(context, output)
         end
       end
 
@@ -61,18 +57,22 @@ module Liquid
       body = BlockBody.new
 
       while markup
-        raise SyntaxError, options[:locale].t('errors.syntax.case_invalid_when') unless markup =~ WHEN_SYNTAX
+        unless markup =~ WhenSyntax
+          raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_when".freeze)
+        end
 
         markup = Regexp.last_match(2)
 
-        block = Condition.new(@left, '==', Expression.parse(Regexp.last_match(1)))
+        block = Condition.new(@left, '=='.freeze, Expression.parse(Regexp.last_match(1)))
         block.attach(body)
         @blocks << block
       end
     end
 
     def record_else_condition(markup)
-      raise SyntaxError, options[:locale].t('errors.syntax.case_invalid_else') unless markup.strip.empty?
+      unless markup.strip.empty?
+        raise SyntaxError, options[:locale].t("errors.syntax.case_invalid_else".freeze)
+      end
 
       block = ElseCondition.new
       block.attach(BlockBody.new)
@@ -86,5 +86,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('case', Case)
+  Template.register_tag('case'.freeze, Case)
 end

lib/liquid/tags/comment.rb

@@ -1,17 +1,16 @@
-# frozen_string_literal: true
-
 module Liquid
   class Comment < Block
     def render_to_output_buffer(_context, output)
       output
     end
 
-    def unknown_tag(_tag, _markup, _tokens); end
+    def unknown_tag(_tag, _markup, _tokens)
+    end
 
     def blank?
       true
     end
   end
 
-  Template.register_tag('comment', Comment)
+  Template.register_tag('comment'.freeze, Comment)
 end

lib/liquid/tags/continue.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Continue tag to be used to break out of a for loop.
   #
@@ -16,5 +14,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('continue', Continue)
+  Template.register_tag('continue'.freeze, Continue)
 end

lib/liquid/tags/cycle.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Cycle is usually used within a loop to alternate between values, like colors or DOM classes.
   #
@@ -14,47 +12,45 @@ module Liquid
   #    <div class="green"> Item five</div>
   #
   class Cycle < Tag
-    SIMPLE_SYNTAX = /\A#{QUOTED_FRAGMENT}+/o.freeze
-    NAMED_SYNTAX  = /\A(#{QUOTED_FRAGMENT})\s*\:\s*(.*)/om.freeze
+    SimpleSyntax = /\A#{QuotedFragment}+/o
+    NamedSyntax  = /\A(#{QuotedFragment})\s*\:\s*(.*)/om
 
     attr_reader :variables
 
     def initialize(tag_name, markup, options)
       super
       case markup
-      when NAMED_SYNTAX
+      when NamedSyntax
         @variables = variables_from_string(Regexp.last_match(2))
         @name = Expression.parse(Regexp.last_match(1))
-      when SIMPLE_SYNTAX
+      when SimpleSyntax
         @variables = variables_from_string(markup)
         @name = @variables.to_s
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.cycle')
+        raise SyntaxError, options[:locale].t("errors.syntax.cycle".freeze)
       end
     end
 
     def render_to_output_buffer(context, output)
       context.registers[:cycle] ||= {}
 
-      context.stack do
-        key = context.evaluate(@name)
-        iteration = context.registers[:cycle][key].to_i
+      key = context.evaluate(@name)
+      iteration = context.registers[:cycle][key].to_i
 
-        val = context.evaluate(@variables[iteration])
+      val = context.evaluate(@variables[iteration])
 
-        if val.is_a?(Array)
-          val = val.join
-        elsif !val.is_a?(String)
-          val = val.to_s
-        end
-
-        output << val
-
-        iteration += 1
-        iteration  = 0 if iteration >= @variables.size
-        context.registers[:cycle][key] = iteration
+      if val.is_a?(Array)
+        val = val.join
+      elsif !val.is_a?(String)
+        val = val.to_s
       end
 
+      output << val
+
+      iteration += 1
+      iteration  = 0 if iteration >= @variables.size
+      context.registers[:cycle][key] = iteration
+
       output
     end
 
@@ -62,7 +58,7 @@ module Liquid
 
     def variables_from_string(markup)
       markup.split(',').collect do |var|
-        var =~ /\s*(#{QUOTED_FRAGMENT})\s*/o
+        var =~ /\s*(#{QuotedFragment})\s*/o
         Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
       end.compact
     end

lib/liquid/tags/decrement.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # decrement is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
@@ -34,5 +32,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('decrement', Decrement)
+  Template.register_tag('decrement'.freeze, Decrement)
 end

lib/liquid/tags/echo.rb

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

lib/liquid/tags/for.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # "For" iterates over an array or collection.
   # Several useful variables are available to you within the loop.
@@ -46,7 +44,7 @@ module Liquid
   # forloop.parentloop:: Provides access to the parent loop, if present.
   #
   class For < Block
-    SYNTAX = /\A(#{VARIABLE_SEGMENT}+)\s+in\s+(#{QUOTED_FRAGMENT}+)\s*(reversed)?/o.freeze
+    Syntax = /\A(#{VariableSegment}+)\s+in\s+(#{QuotedFragment}+)\s*(reversed)?/o
 
     attr_reader :collection_name, :variable_name, :limit, :from
 
@@ -60,7 +58,6 @@ module Liquid
 
     def parse(tokens)
       return unless parse_body(@for_block, tokens)
-
       parse_body(@else_block, tokens)
     end
 
@@ -69,8 +66,7 @@ module Liquid
     end
 
     def unknown_tag(tag, markup, tokens)
-      return super unless tag == 'else'
-
+      return super unless tag == 'else'.freeze
       @else_block = BlockBody.new
     end
 
@@ -89,35 +85,33 @@ module Liquid
     protected
 
     def lax_parse(markup)
-      if markup =~ SYNTAX
+      if markup =~ Syntax
         @variable_name = Regexp.last_match(1)
         collection_name = Regexp.last_match(2)
         @reversed = !!Regexp.last_match(3)
         @name = "#{@variable_name}-#{collection_name}"
         @collection_name = Expression.parse(collection_name)
-        markup.scan(TAG_ATTRIBUTES) do |key, value|
+        markup.scan(TagAttributes) do |key, value|
           set_attribute(key, value)
         end
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.for')
+        raise SyntaxError, 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') unless p.id?('in')
-
+      raise SyntaxError, 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)
-      @reversed = p.id?('reversed')
+      @reversed = p.id?('reversed'.freeze)
 
       while p.look(:id) && p.look(:colon, 1)
-        unless (attribute = p.id?('limit') || p.id?('offset'))
-          raise SyntaxError, options[:locale].t('errors.syntax.for_invalid_attribute')
+        unless attribute = p.id?('limit'.freeze) || p.id?('offset'.freeze)
+          raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_attribute".freeze)
         end
-
         p.consume
         set_attribute(attribute, p.expression)
       end
@@ -168,7 +162,7 @@ module Liquid
         for_stack.push(loop_vars)
 
         begin
-          context['forloop'] = loop_vars
+          context['forloop'.freeze] = loop_vars
 
           segment.each do |item|
             context[@variable_name] = item
@@ -177,7 +171,6 @@ module Liquid
 
             # Handle any interrupts if they exist.
             next unless context.interrupt?
-
             interrupt = context.pop_interrupt
             break if interrupt.is_a?(BreakInterrupt)
             next if interrupt.is_a?(ContinueInterrupt)
@@ -192,13 +185,13 @@ module Liquid
 
     def set_attribute(key, expr)
       case key
-      when 'offset'
-        @from = if expr == 'continue'
+      when 'offset'.freeze
+        @from = if expr == 'continue'.freeze
           :continue
         else
           Expression.parse(expr)
         end
-      when 'limit'
+      when 'limit'.freeze
         @limit = Expression.parse(expr)
       end
     end
@@ -218,5 +211,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('for', For)
+  Template.register_tag('for'.freeze, For)
 end

lib/liquid/tags/if.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # If is the conditional block
   #
@@ -12,16 +10,16 @@ module Liquid
   #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
   #
   class If < Block
-    SYNTAX = /(#{QUOTED_FRAGMENT})\s*([=!<>a-z_]+)?\s*(#{QUOTED_FRAGMENT})?/o.freeze
-    EXPRESSIONS_AND_OPERATORS = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QUOTED_FRAGMENT}|\S+)\s*)+)/o.freeze
-    BOOLEAN_OPERATORS = %w[and or].freeze
+    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
 
     attr_reader :blocks
 
     def initialize(tag_name, markup, options)
       super
       @blocks = []
-      push_block('if', markup)
+      push_block('if'.freeze, markup)
     end
 
     def nodelist
@@ -34,7 +32,7 @@ module Liquid
     end
 
     def unknown_tag(tag, markup, tokens)
-      if %w[elsif else].include?(tag)
+      if ['elsif'.freeze, 'else'.freeze].include?(tag)
         push_block(tag, markup)
       else
         super
@@ -42,9 +40,9 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      context.stack do
-        @blocks.each do |block|
-          return block.attachment.render_to_output_buffer(context, output) if block.evaluate(context)
+      @blocks.each do |block|
+        if block.evaluate(context)
+          return block.attachment.render_to_output_buffer(context, output)
         end
       end
 
@@ -54,7 +52,7 @@ module Liquid
     private
 
     def push_block(tag, markup)
-      block = if tag == 'else'
+      block = if tag == 'else'.freeze
         ElseCondition.new
       else
         parse_with_selected_parser(markup)
@@ -65,19 +63,18 @@ module Liquid
     end
 
     def lax_parse(markup)
-      expressions = markup.scan(EXPRESSIONS_AND_OPERATORS)
-      raise SyntaxError, options[:locale].t('errors.syntax.if') unless expressions.pop =~ SYNTAX
+      expressions = markup.scan(ExpressionsAndOperators)
+      raise SyntaxError, 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)))
 
       until expressions.empty?
         operator = expressions.pop.to_s.strip
 
-        raise SyntaxError, options[:locale].t('errors.syntax.if') unless expressions.pop.to_s =~ SYNTAX
+        raise SyntaxError, 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)))
-        raise SyntaxError, options[:locale].t('errors.syntax.if') unless BOOLEAN_OPERATORS.include?(operator)
-
+        raise SyntaxError, options[:locale].t("errors.syntax.if".freeze) unless BOOLEAN_OPERATORS.include?(operator)
         new_condition.send(operator, condition)
         condition = new_condition
       end
@@ -95,7 +92,7 @@ module Liquid
     def parse_binary_comparisons(p)
       condition = parse_comparison(p)
       first_condition = condition
-      while (op = (p.id?('and') || p.id?('or')))
+      while op = (p.id?('and'.freeze) || p.id?('or'.freeze))
         child_condition = parse_comparison(p)
         condition.send(op, child_condition)
         condition = child_condition
@@ -105,7 +102,7 @@ module Liquid
 
     def parse_comparison(p)
       a = Expression.parse(p.expression)
-      if (op = p.consume?(:comparison))
+      if op = p.consume?(:comparison)
         b = Expression.parse(p.expression)
         Condition.new(a, op, b)
       else
@@ -120,5 +117,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('if', If)
+  Template.register_tag('if'.freeze, If)
 end

lib/liquid/tags/ifchanged.rb

@@ -1,21 +1,17 @@
-# frozen_string_literal: true
-
 module Liquid
   class Ifchanged < Block
     def render_to_output_buffer(context, output)
-      context.stack do
-        block_output = +''
-        super(context, block_output)
+      block_output = ''
+      super(context, block_output)
 
-        if block_output != context.registers[:ifchanged]
-          context.registers[:ifchanged] = block_output
-          output << block_output
-        end
+      if block_output != context.registers[:ifchanged]
+        context.registers[:ifchanged] = block_output
+        output << block_output
       end
 
       output
     end
   end
 
-  Template.register_tag('ifchanged', Ifchanged)
+  Template.register_tag('ifchanged'.freeze, Ifchanged)
 end

lib/liquid/tags/include.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Include allows templates to relate with other templates
   #
@@ -16,14 +14,14 @@ module Liquid
   #   {% include 'product' for products %}
   #
   class Include < Tag
-    SYNTAX = /(#{QUOTED_FRAGMENT}+)(\s+(?:with|for)\s+(#{QUOTED_FRAGMENT}+))?/o.freeze
+    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
+      if markup =~ Syntax
 
         template_name = Regexp.last_match(1)
         variable_name = Regexp.last_match(3)
@@ -32,23 +30,29 @@ module Liquid
         @template_name_expr = Expression.parse(template_name)
         @attributes = {}
 
-        markup.scan(TAG_ATTRIBUTES) do |key, value|
+        markup.scan(TagAttributes) do |key, value|
           @attributes[key] = Expression.parse(value)
         end
 
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.include')
+        raise SyntaxError, options[:locale].t("errors.syntax.include".freeze)
       end
     end
 
-    def parse(_tokens); end
+    def parse(_tokens)
+    end
 
     def render_to_output_buffer(context, output)
       template_name = context.evaluate(@template_name_expr)
-      raise ArgumentError, options[:locale].t('errors.argument.include') unless template_name
+      raise ArgumentError, options[:locale].t("errors.argument.include") unless template_name
 
-      partial = load_cached_partial(template_name, context)
-      context_variable_name = template_name.split('/').last
+      partial = PartialCache.load(
+        template_name,
+        context: context,
+        parse_context: parse_context
+      )
+
+      context_variable_name = template_name.split('/'.freeze).last
 
       variable = if @variable_name_expr
         context.evaluate(@variable_name_expr)
@@ -84,36 +88,9 @@ module Liquid
       output
     end
 
-    private
-
     alias_method :parse_context, :options
     private :parse_context
 
-    def load_cached_partial(template_name, context)
-      cached_partials = context.registers[:cached_partials] || {}
-
-      if (cached = cached_partials[template_name])
-        return cached
-      end
-
-      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
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [
@@ -124,5 +101,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('include', Include)
+  Template.register_tag('include'.freeze, Include)
 end

lib/liquid/tags/increment.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # increment is used in a place where one needs to insert a counter
   #     into a template, and needs the counter to survive across
@@ -25,10 +23,11 @@ module Liquid
     def render_to_output_buffer(context, output)
       value = context.environments.first[@variable] ||= 0
       context.environments.first[@variable] = value + 1
+
       output << value.to_s
       output
     end
   end
 
-  Template.register_tag('increment', Increment)
+  Template.register_tag('increment'.freeze, Increment)
 end

lib/liquid/tags/raw.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
   class Raw < Block
-    SYNTAX = /\A\s*\z/.freeze
-    FULL_TOKEN_POSSIBLY_INVALID = /\A(.*)#{TAG_START}\s*(\w+)\s*(.*)?#{TAG_END}\z/om.freeze
+    Syntax = /\A\s*\z/
+    FullTokenPossiblyInvalid = /\A(.*)#{TagStart}\s*(\w+)\s*(.*)?#{TagEnd}\z/om
 
     def initialize(tag_name, markup, parse_context)
       super
@@ -12,16 +10,16 @@ module Liquid
     end
 
     def parse(tokens)
-      @body = +''
-      while (token = tokens.shift)
-        if token =~ FULL_TOKEN_POSSIBLY_INVALID
-          @body << Regexp.last_match(1) if Regexp.last_match(1) != ''
+      @body = ''
+      while token = tokens.shift
+        if token =~ FullTokenPossiblyInvalid
+          @body << Regexp.last_match(1) if Regexp.last_match(1) != "".freeze
           return if block_delimiter == Regexp.last_match(2)
         end
         @body << token unless token.empty?
       end
 
-      raise SyntaxError, parse_context.locale.t('errors.syntax.tag_never_closed', block_name: block_name)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed".freeze, block_name: block_name)
     end
 
     def render_to_output_buffer(_context, output)
@@ -40,9 +38,11 @@ module Liquid
     protected
 
     def ensure_valid_markup(tag_name, markup, parse_context)
-      raise SyntaxError, parse_context.locale.t('errors.syntax.tag_unexpected_args', tag: tag_name) unless markup =~ SYNTAX
+      unless markup =~ Syntax
+        raise SyntaxError, parse_context.locale.t("errors.syntax.tag_unexpected_args".freeze, tag: tag_name)
+      end
     end
   end
 
-  Template.register_tag('raw', Raw)
+  Template.register_tag('raw'.freeze, Raw)
 end

lib/liquid/tags/render.rb

@@ -0,0 +1,54 @@
+module Liquid
+  class Render < Tag
+    SYNTAX = /(#{QuotedString})#{QuotedFragment}*/o
+
+    attr_reader :template_name_expr, :attributes
+
+    def initialize(tag_name, markup, options)
+      super
+
+      raise SyntaxError, 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

@@ -1,41 +1,39 @@
-# frozen_string_literal: true
-
 module Liquid
   class TableRow < Block
-    SYNTAX = /(\w+)\s+in\s+(#{QUOTED_FRAGMENT}+)/o.freeze
+    Syntax = /(\w+)\s+in\s+(#{QuotedFragment}+)/o
 
     attr_reader :variable_name, :collection_name, :attributes
 
     def initialize(tag_name, markup, options)
       super
-      if markup =~ SYNTAX
+      if markup =~ Syntax
         @variable_name = Regexp.last_match(1)
         @collection_name = Expression.parse(Regexp.last_match(2))
         @attributes = {}
-        markup.scan(TAG_ATTRIBUTES) do |key, value|
+        markup.scan(TagAttributes) do |key, value|
           @attributes[key] = Expression.parse(value)
         end
       else
-        raise SyntaxError, options[:locale].t('errors.syntax.table_row')
+        raise SyntaxError, options[:locale].t("errors.syntax.table_row".freeze)
       end
     end
 
     def render_to_output_buffer(context, output)
-      (collection = context.evaluate(@collection_name)) || (return '')
+      (collection = context.evaluate(@collection_name)) || (return ''.freeze)
 
-      from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
-      to = @attributes.key?('limit') ? from + context.evaluate(@attributes['limit']).to_i : nil
+      from = @attributes.key?('offset'.freeze) ? context.evaluate(@attributes['offset'.freeze]).to_i : 0
+      to = @attributes.key?('limit'.freeze) ? from + context.evaluate(@attributes['limit'.freeze]).to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
 
       length = collection.length
 
-      cols = context.evaluate(@attributes['cols']).to_i
+      cols = context.evaluate(@attributes['cols'.freeze]).to_i
 
       output << "<tr class=\"row1\">\n"
       context.stack do
         tablerowloop = Liquid::TablerowloopDrop.new(length, cols)
-        context['tablerowloop'] = tablerowloop
+        context['tablerowloop'.freeze] = tablerowloop
 
         collection.each do |item|
           context[@variable_name] = item
@@ -44,7 +42,9 @@ module Liquid
           super
           output << '</td>'
 
-          output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">" if tablerowloop.col_last && !tablerowloop.last
+          if tablerowloop.col_last && !tablerowloop.last
+            output << "</tr>\n<tr class=\"row#{tablerowloop.row + 1}\">"
+          end
 
           tablerowloop.send(:increment!)
         end
@@ -61,5 +61,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('tablerow', TableRow)
+  Template.register_tag('tablerow'.freeze, TableRow)
 end

lib/liquid/tags/unless.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require_relative 'if'
 
 module Liquid
@@ -9,14 +7,16 @@ module Liquid
   #
   class Unless < If
     def render_to_output_buffer(context, output)
-      context.stack do
-        # First condition is interpreted backwards ( if not )
-        first_block = @blocks.first
-        return first_block.attachment.render_to_output_buffer(context, output) unless first_block.evaluate(context)
+      # First condition is interpreted backwards ( if not )
+      first_block = @blocks.first
+      unless first_block.evaluate(context)
+        return first_block.attachment.render_to_output_buffer(context, output)
+      end
 
-        # After the first condition unless works just like if
-        @blocks[1..-1].each do |block|
-          return block.attachment.render_to_output_buffer(context, output) if block.evaluate(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
 
@@ -24,5 +24,5 @@ module Liquid
     end
   end
 
-  Template.register_tag('unless', Unless)
+  Template.register_tag('unless'.freeze, Unless)
 end

lib/liquid/template.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Templates are central to liquid.
   # Interpretating templates is a two step process. First you compile the
@@ -18,11 +16,7 @@ module Liquid
     attr_accessor :root
     attr_reader :resource_limits, :warnings
 
-    @file_system = BlankFileSystem.new
-
-    class << self
-      attr_accessor :file_system
-    end
+    @@file_system = BlankFileSystem.new
 
     class TagRegistry
       include Enumerable
@@ -80,6 +74,14 @@ module Liquid
         exception
       end
 
+      def file_system
+        @@file_system
+      end
+
+      def file_system=(obj)
+        @@file_system = obj
+      end
+
       def register_tag(name, klass)
         tags[name.to_s] = klass
       end
@@ -141,7 +143,12 @@ module Liquid
     end
 
     def instance_assigns
-      @instance_assigns ||= {}
+      @instance_assigns ||= []
+    end
+
+    def new_outer_scope
+      @instance_assigns.unshift(last = {})
+      last
     end
 
     def errors
@@ -163,24 +170,26 @@ module Liquid
     #    filters and tags and might be useful to integrate liquid more with its host application
     #
     def render(*args)
-      return '' if @root.nil?
+      return ''.freeze if @root.nil?
 
       context = case args.first
       when Liquid::Context
         c = args.shift
 
-        c.exception_renderer = ->(_e) { raise } if @rethrow_errors
+        if @rethrow_errors
+          c.exception_renderer = ->(_e) { raise }
+        end
 
         c
       when Liquid::Drop
         drop = args.shift
-        drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
+        drop.context = Context.new([drop, assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
       when Hash
-        Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
+        Context.new([args.shift, assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
       when nil
-        Context.new(assigns, instance_assigns, registers, @rethrow_errors, @resource_limits)
+        Context.new([assigns].concat(instance_assigns), new_outer_scope, registers, @rethrow_errors, @resource_limits)
       else
-        raise ArgumentError, 'Expected Hash or Liquid::Context as parameter'
+        raise ArgumentError, "Expected Hash or Liquid::Context as parameter"
       end
 
       output = nil
@@ -204,7 +213,7 @@ module Liquid
         # render the nodelist.
         # for performance reasons we get an array back here. join will make a string out of it.
         with_profiling(context) do
-          @root.render_to_output_buffer(context, output || +'')
+          @root.render_to_output_buffer(context, output || '')
         end
       rescue Liquid::MemoryError => e
         context.handle_error(e)

lib/liquid/tokenizer.rb

@@ -1,28 +1,32 @@
-# frozen_string_literal: true
-
 module Liquid
   class Tokenizer
-    attr_reader :line_number
+    attr_reader :line_number, :for_liquid_tag
 
-    def initialize(source, line_numbers = false)
+    def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
       @source = source
-      @line_number = line_numbers ? 1 : nil
+      @line_number = line_number || (line_numbers ? 1 : nil)
+      @for_liquid_tag = for_liquid_tag
       @tokens = tokenize
     end
 
     def shift
-      token = @tokens.shift
-      @line_number += token.count("\n") if @line_number && token
+      (token = @tokens.shift) || return
+
+      if @line_number
+        @line_number += @for_liquid_tag ? 1 : token.count("\n")
+      end
+
       token
     end
 
     private
 
     def tokenize
-      @source = @source.source if @source.respond_to?(:source)
       return [] if @source.to_s.empty?
 
-      tokens = @source.split(TEMPLATE_PARSER)
+      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?

lib/liquid/usage.rb

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

lib/liquid/utils.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   module Utils
     def self.slice_collection(collection, from, to)
@@ -21,9 +19,13 @@ module Liquid
       return [] unless collection.respond_to?(:each)
 
       collection.each do |item|
-        break if to && to <= index
+        if to && to <= index
+          break
+        end
 
-        segments << item if from <= index
+        if from <= index
+          segments << item
+        end
 
         index += 1
       end
@@ -33,12 +35,11 @@ module Liquid
 
     def self.to_integer(num)
       return num if num.is_a?(Integer)
-
       num = num.to_s
       begin
         Integer(num)
       rescue ::ArgumentError
-        raise Liquid::ArgumentError, 'invalid integer'
+        raise Liquid::ArgumentError, "invalid integer"
       end
     end
 
@@ -64,12 +65,11 @@ module Liquid
 
       if obj.is_a?(String)
         return nil if obj.empty?
-
         obj = obj.downcase
       end
 
       case obj
-      when 'now', 'today'
+      when 'now'.freeze, 'today'.freeze
         Time.now
       when /\A\d+\z/, Integer
         Time.at(obj.to_i)

lib/liquid/variable.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module Liquid
   # Holds variables. Variables are only loaded "just in time"
   # and are not evaluated as part of the render stage
@@ -12,11 +10,11 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FILTER_MARKUP_REGEX = /#{FILTER_SEPARATOR}\s*(.*)/om.freeze
-    FILTER_PARSER = /(?:\s+|#{QUOTED_FRAGMENT}|#{ARGUMENT_SEPARATOR})+/o.freeze
-    FILTER_ARGS_REGEX = /(?:#{FILTER_ARGUMENT_SEPARATOR}|#{ARGUMENT_SEPARATOR})\s*((?:\w+\s*\:\s*)?#{QUOTED_FRAGMENT})/o.freeze
-    JUST_TAG_ATTRIBUTES = /\A#{TAG_ATTRIBUTES}\z/o.freeze
-    MARKUP_WITH_QUOTED_FRAGMENT = /(#{QUOTED_FRAGMENT})(.*)/om.freeze
+    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
@@ -43,18 +41,17 @@ module Liquid
 
     def lax_parse(markup)
       @filters = []
-      return unless markup =~ MARKUP_WITH_QUOTED_FRAGMENT
+      return unless markup =~ MarkupWithQuotedFragment
 
       name_markup = Regexp.last_match(1)
       filter_markup = Regexp.last_match(2)
       @name = Expression.parse(name_markup)
-      if filter_markup =~ FILTER_MARKUP_REGEX
-        filters = Regexp.last_match(1).scan(FILTER_PARSER)
+      if filter_markup =~ FilterMarkupRegex
+        filters = Regexp.last_match(1).scan(FilterParser)
         filters.each do |f|
           next unless f =~ /\w+/
-
           filtername = Regexp.last_match(0)
-          filterargs = f.scan(FILTER_ARGS_REGEX).flatten
+          filterargs = f.scan(FilterArgsRegex).flatten
           @filters << parse_filter_expressions(filtername, filterargs)
         end
       end
@@ -111,7 +108,7 @@ module Liquid
       filter_args = []
       keyword_args = nil
       unparsed_args.each do |a|
-        if (matches = a.match(JUST_TAG_ATTRIBUTES))
+        if matches = a.match(JustTagAttributes)
           keyword_args ||= {}
           keyword_args[matches[1]] = Expression.parse(matches[2])
         else
@@ -139,7 +136,7 @@ module Liquid
       return unless obj.tainted?
       return if Template.taint_mode == :lax
 
-      @markup =~ QUOTED_FRAGMENT
+      @markup =~ QuotedFragment
       name = Regexp.last_match(0)
 
       error = TaintedError.new("variable '#{name}' is tainted and was not escaped")

lib/liquid/variable_lookup.rb

@@ -1,9 +1,7 @@
-# frozen_string_literal: true
-
 module Liquid
   class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m.freeze
-    COMMAND_METHODS = %w[size first last].freeze
+    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
+    COMMAND_METHODS = ['size'.freeze, 'first'.freeze, 'last'.freeze].freeze
 
     attr_reader :name, :lookups
 
@@ -12,10 +10,12 @@ module Liquid
     end
 
     def initialize(markup)
-      lookups = markup.scan(VARIABLE_PARSER)
+      lookups = markup.scan(VariableParser)
 
       name = lookups.shift
-      name = Expression.parse(Regexp.last_match(1)) if name =~ SQUARE_BRACKETED
+      if name =~ SQUARE_BRACKETED
+        name = Expression.parse(Regexp.last_match(1))
+      end
       @name = name
 
       @lookups = lookups
@@ -41,8 +41,8 @@ module Liquid
         # If object is a hash- or array-like object we look for the
         # presence of the key and if its available we return it
         if object.respond_to?(:[]) &&
-           ((object.respond_to?(:key?) && object.key?(key)) ||
-            (object.respond_to?(:fetch) && key.is_a?(Integer)))
+            ((object.respond_to?(:key?) && object.key?(key)) ||
+             (object.respond_to?(:fetch) && key.is_a?(Integer)))
 
           # if its a proc we will replace the entry with the proc
           res = context.lookup_and_evaluate(object, key)
@@ -59,7 +59,6 @@ module Liquid
           # raise an exception if `strict_variables` option is set to true
         else
           return nil unless context.strict_variables
-
           raise Liquid::UndefinedVariable, "undefined variable #{key}"
         end
 

lib/liquid/version.rb

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

liquid.gemspec

@@ -1,31 +1,31 @@
-# frozen_string_literal: true
+# encoding: utf-8
 
-lib = File.expand_path('lib', __dir__)
+lib = File.expand_path('../lib/', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
-require 'liquid/version'
+require "liquid/version"
 
 Gem::Specification.new do |s|
-  s.name        = 'liquid'
+  s.name        = "liquid"
   s.version     = Liquid::VERSION
   s.platform    = Gem::Platform::RUBY
-  s.summary     = 'A secure, non-evaling end user template engine with aesthetic markup.'
-  s.authors     = ['Tobias Lütke']
-  s.email       = ['tobi@leetsoft.com']
-  s.homepage    = 'http://www.liquidmarkup.org'
-  s.license     = 'MIT'
+  s.summary     = "A secure, non-evaling end user template engine with aesthetic markup."
+  s.authors     = ["Tobias Lütke"]
+  s.email       = ["tobi@leetsoft.com"]
+  s.homepage    = "http://www.liquidmarkup.org"
+  s.license     = "MIT"
   # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_ruby_version     = '>= 2.4.0'
-  s.required_rubygems_version = '>= 1.3.7'
+  s.required_ruby_version     = ">= 2.4.0"
+  s.required_rubygems_version = ">= 1.3.7"
 
-  s.test_files  = Dir.glob('{test}/**/*')
-  s.files       = Dir.glob('{lib}/**/*') + %w[LICENSE README.md]
+  s.test_files  = Dir.glob("{test}/**/*")
+  s.files       = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
 
-  s.extra_rdoc_files = ['History.md', 'README.md']
+  s.extra_rdoc_files = ["History.md", "README.md"]
 
-  s.require_path = 'lib'
+  s.require_path = "lib"
 
-  s.add_development_dependency('minitest')
   s.add_development_dependency('rake', '~> 11.3')
+  s.add_development_dependency('minitest')
 end

performance/benchmark.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'benchmark/ips'
 require_relative 'theme_runner'
 
@@ -14,7 +12,7 @@ Benchmark.ips do |x|
   puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
   puts
 
-  x.report('parse:') { profiler.compile }
-  x.report('render:') { profiler.render }
-  x.report('parse & render:') { profiler.run }
+  x.report("parse:") { profiler.compile }
+  x.report("render:") { profiler.render }
+  x.report("parse & render:") { profiler.run }
 end

performance/memory_profile.rb

@@ -2,25 +2,62 @@
 
 require 'benchmark/ips'
 require 'memory_profiler'
+require 'terminal-table'
 require_relative 'theme_runner'
 
-def profile(phase, &block)
-  puts
-  puts "#{phase}:"
-  puts
+class Profiler
+  LOG_LABEL   = "Profiling: ".rjust(14).freeze
+  REPORTS_DIR = File.expand_path('.memprof', __dir__).freeze
 
-  report = MemoryProfiler.report(&block)
+  def self.run
+    puts
+    yield new
+  end
 
-  report.pretty_print(
-    color_output: true,
-    scale_bytes: true,
-    detailed_report: true
-  )
+  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
 
-profiler = ThemeRunner.new
-
-profile('Parsing') { profiler.compile }
-profile('Rendering') { profiler.render }
+runner = ThemeRunner.new
+Profiler.run do |x|
+  x.profile('parse') { runner.compile }
+  x.profile('render') { runner.render }
+  x.tabulate
+end

performance/profile.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'stackprof'
 require_relative 'theme_runner'
 
@@ -7,7 +5,7 @@ Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run
 
-%i[cpu object].each do |profile_type|
+[:cpu, :object].each do |profile_type|
   puts "Profiling in #{profile_type} mode..."
   results = StackProf.run(mode: profile_type) do
     200.times do
@@ -15,12 +13,12 @@ profiler.run
     end
   end
 
-  if profile_type == :cpu && (graph_filename = ENV['GRAPH_FILENAME'])
+  if profile_type == :cpu && graph_filename = ENV['GRAPH_FILENAME']
     File.open(graph_filename, 'w') do |f|
       StackProf::Report.new(results).print_graphviz(nil, f)
     end
   end
 
   StackProf::Report.new(results).print_text(false, 20)
-  File.write(ENV['FILENAME'] + '.' + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
+  File.write(ENV['FILENAME'] + "." + profile_type.to_s, Marshal.dump(results)) if ENV['FILENAME']
 end

performance/shopify/comment_form.rb

@@ -1,12 +1,10 @@
-# frozen_string_literal: true
-
 class CommentForm < Liquid::Block
-  SYNTAX = /(#{Liquid::VARIABLE_SIGNATURE}+)/.freeze
+  Syntax = /(#{Liquid::VariableSignature}+)/
 
   def initialize(tag_name, markup, options)
     super
 
-    if markup =~ SYNTAX
+    if markup =~ Syntax
       @variable_name = Regexp.last_match(1)
       @attributes = {}
     else

performance/shopify/database.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'yaml'
 
 module Database
@@ -21,9 +19,7 @@ module Database
       db = db.each_with_object({}) do |(key, values), assigns|
         assigns[key] = values.each_with_object({}) do |v, h|
           h[v['handle']] = v
-          h
         end
-        assigns
       end
 
       # Some standard direct accessors so that the specialized templates
@@ -34,8 +30,8 @@ module Database
       db['article']    = db['blog']['articles'].first
 
       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'] },
+        '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'] },
         'items' => db['line_items'].values,
       }
 

performance/shopify/json_filter.rb

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

performance/shopify/liquid.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 $LOAD_PATH.unshift(__dir__ + '/../../lib')
 require_relative '../../lib/liquid'
 

performance/shopify/money_filter.rb

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

performance/shopify/paginate.rb

@@ -1,12 +1,10 @@
-# frozen_string_literal: true
-
 class Paginate < Liquid::Block
-  SYNTAX = /(#{Liquid::QUOTED_FRAGMENT})\s*(by\s*(\d+))?/.freeze
+  Syntax = /(#{Liquid::QuotedFragment})\s*(by\s*(\d+))?/
 
   def initialize(tag_name, markup, options)
     super
 
-    if markup =~ SYNTAX
+    if markup =~ Syntax
       @collection_name = Regexp.last_match(1)
       @page_size = if Regexp.last_match(2)
         Regexp.last_match(3).to_i
@@ -15,7 +13,7 @@ class Paginate < Liquid::Block
       end
 
       @attributes = { 'window_size' => 3 }
-      markup.scan(Liquid::TAG_ATTRIBUTES) do |key, value|
+      markup.scan(Liquid::TagAttributes) do |key, value|
         @attributes[key] = value
       end
     else
@@ -45,7 +43,7 @@ class Paginate < Liquid::Block
 
       pagination['items']      = collection_size
       pagination['pages']      = page_count - 1
-      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless current_page <= 1
+      pagination['previous']   = link('&laquo; Previous', current_page - 1)  unless 1 >= current_page
       pagination['next']       = link('Next &raquo;', current_page + 1)      unless page_count <= current_page + 1
       pagination['parts']      = []
 
@@ -61,7 +59,6 @@ class Paginate < Liquid::Block
             pagination['parts'] << link(page, page)
           elsif page <= current_page - @attributes['window_size'] || page >= current_page + @attributes['window_size']
             next if hellip_break
-
             pagination['parts'] << no_link('&hellip;')
             hellip_break = true
             next
@@ -88,6 +85,6 @@ class Paginate < Liquid::Block
   end
 
   def current_url
-    '/collections/frontpage'
+    "/collections/frontpage"
   end
 end

performance/shopify/shop_filter.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module ShopFilter
   def asset_url(input)
     "/files/1/[shop_id]/[shop_id]/assets/#{input}"
@@ -17,15 +15,15 @@ module ShopFilter
     %(<script src="#{url}" type="text/javascript"></script>)
   end
 
-  def stylesheet_tag(url, media = 'all')
+  def stylesheet_tag(url, media = "all")
     %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
   end
 
-  def link_to(link, url, title = '')
+  def link_to(link, url, title = "")
     %(<a href="#{url}" title="#{title}">#{link}</a>)
   end
 
-  def img_tag(url, alt = '')
+  def img_tag(url, alt = "")
     %(<img src="#{url}" alt="#{alt}" />)
   end
 
@@ -54,7 +52,9 @@ module ShopFilter
   end
 
   def product_img_url(url, style = 'small')
-    raise ArgumentError, 'filter "size" can only be called on product images' unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
+    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
+      raise ArgumentError, 'filter "size" can only be called on product images'
+    end
 
     case style
     when 'original'

performance/shopify/tag_filter.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 module TagFilter
   def link_to_tag(label, tag)
     "<a title=\"Show tag #{tag}\" href=\"/collections/#{@context['handle']}/#{tag}\">#{label}</a>"

performance/shopify/weight_filter.rb

@@ -1,8 +1,6 @@
-# frozen_string_literal: true
-
 module WeightFilter
   def weight(grams)
-    format('%.2f', grams / 1000)
+    format("%.2f", grams / 1000)
   end
 
   def weight_with_unit(grams)

performance/theme_runner.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 # This profiler run simulates Shopify.
 # We are looking in the tests directory for liquid files and render them within the designated layout file.
 # We will also export a substantial database to liquid which the templates can render values of.

test/integration/assign_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class AssignTest < Minitest::Test
@@ -12,29 +10,29 @@ class AssignTest < Minitest::Test
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal 'Print this-thing', rendered.strip
+    assert_equal "Print this-thing", rendered.strip
   end
 
   def test_assigned_variable
     assert_template_result('.foo.',
-                           '{% assign foo = values %}.{{ foo[0] }}.',
-                           'values' => %w[foo bar baz])
+      '{% assign foo = values %}.{{ foo[0] }}.',
+      'values' => %w(foo bar baz))
 
     assert_template_result('.bar.',
-                           '{% assign foo = values %}.{{ foo[1] }}.',
-                           'values' => %w[foo bar baz])
+      '{% assign foo = values %}.{{ foo[1] }}.',
+      'values' => %w(foo bar baz))
   end
 
   def test_assign_with_filter
     assert_template_result('.bar.',
-                           '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
-                           'values' => 'foo,bar,baz')
+      '{% assign foo = values | split: "," %}.{{ foo[1] }}.',
+      'values' => "foo,bar,baz")
   end
 
   def test_assign_syntax_error
     assert_match_syntax_error(/assign/,
-                              '{% assign foo not values %}.',
-                              'values' => 'foo,bar,baz')
+      '{% assign foo not values %}.',
+      'values' => "foo,bar,baz")
   end
 
   def test_assign_uses_error_mode

test/integration/blank_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class FoobarTag < Liquid::Tag
@@ -33,77 +31,77 @@ class BlankTest < Minitest::Test
 
   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
-    assert_template_result('', wrap_in_for(' '))
+    assert_template_result("", wrap_in_for(" "))
   end
 
   def test_if_else_are_blank
-    assert_template_result('', '{% if true %} {% elsif false %} {% else %} {% endif %}')
+    assert_template_result("", "{% if true %} {% elsif false %} {% else %} {% endif %}")
   end
 
   def test_unless_is_blank
-    assert_template_result('', wrap('{% unless true %} {% endunless %}'))
+    assert_template_result("", wrap("{% unless true %} {% endunless %}"))
   end
 
   def test_mark_as_blank_only_during_parsing
-    assert_template_result(' ' * (N + 1), wrap(' {% if false %} this never happens, but still, this block is not blank {% endif %}'))
+    assert_template_result(" " * (N + 1), wrap(" {% if false %} this never happens, but still, this block is not blank {% endif %}"))
   end
 
   def test_comments_are_blank
-    assert_template_result('', wrap(' {% comment %} whatever {% endcomment %} '))
+    assert_template_result("", wrap(" {% comment %} whatever {% endcomment %} "))
   end
 
   def test_captures_are_blank
-    assert_template_result('', wrap(' {% capture foo %} whatever {% endcapture %} '))
+    assert_template_result("", wrap(" {% capture foo %} whatever {% endcapture %} "))
   end
 
   def test_nested_blocks_are_blank_but_only_if_all_children_are
-    assert_template_result('', wrap(wrap(' ')))
+    assert_template_result("", wrap(wrap(" ")))
     assert_template_result("\n       but this is not " * (N + 1),
-                           wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
+      wrap('{% if true %} {% comment %} this is blank {% endcomment %} {% endif %}
       {% if true %} but this is not {% endif %}'))
   end
 
   def test_assigns_are_blank
-    assert_template_result('', wrap(' {% assign foo = "bar" %} '))
+    assert_template_result("", wrap(' {% assign foo = "bar" %} '))
   end
 
   def test_whitespace_is_blank
-    assert_template_result('', wrap(' '))
-    assert_template_result('', wrap("\t"))
+    assert_template_result("", wrap(" "))
+    assert_template_result("", wrap("\t"))
   end
 
   def test_whitespace_is_not_blank_if_other_stuff_is_present
-    body = '     x '
+    body = "     x "
     assert_template_result(body * (N + 1), wrap(body))
   end
 
   def test_increment_is_not_blank
-    assert_template_result(' 0' * 2 * (N + 1), wrap('{% assign foo = 0 %} {% increment foo %} {% decrement foo %}'))
+    assert_template_result(" 0" * 2 * (N + 1), wrap("{% assign foo = 0 %} {% increment foo %} {% decrement foo %}"))
   end
 
   def test_cycle_is_not_blank
-    assert_template_result('  ' * ((N + 1) / 2) + ' ', wrap("{% cycle ' ', ' ' %}"))
+    assert_template_result("  " * ((N + 1) / 2) + " ", wrap("{% cycle ' ', ' ' %}"))
   end
 
   def test_raw_is_not_blank
-    assert_template_result('  ' * (N + 1), wrap(' {% raw %} {% endraw %}'))
+    assert_template_result("  " * (N + 1), wrap(" {% raw %} {% endraw %}"))
   end
 
   def test_include_is_blank
     Liquid::Template.file_system = BlankTestFileSystem.new
-    assert_template_result 'foobar' * (N + 1), wrap("{% include 'foobar' %}")
-    assert_template_result ' foobar ' * (N + 1), wrap("{% include ' foobar ' %}")
-    assert_template_result '   ' * (N + 1), wrap(" {% include ' ' %} ")
+    assert_template_result "foobar" * (N + 1), wrap("{% include 'foobar' %}")
+    assert_template_result " foobar " * (N + 1), wrap("{% include ' foobar ' %}")
+    assert_template_result "   " * (N + 1), wrap(" {% include ' ' %} ")
   end
 
   def test_case_is_blank
-    assert_template_result('', wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
-    assert_template_result('', wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
-    assert_template_result('   x  ' * (N + 1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
+    assert_template_result("", wrap(" {% assign foo = 'bar' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
+    assert_template_result("", wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} {% endcase %} "))
+    assert_template_result("   x  " * (N + 1), wrap(" {% assign foo = 'else' %} {% case foo %} {% when 'bar' %} {% when 'whatever' %} {% else %} x {% endcase %} "))
   end
 end

test/integration/block_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class BlockTest < Minitest::Test
@@ -7,7 +5,7 @@ class BlockTest < Minitest::Test
 
   def test_unexpected_end_tag
     exc = assert_raises(SyntaxError) do
-      Template.parse('{% if true %}{% endunless %}')
+      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

test/integration/capture_test.rb

@@ -1,12 +1,10 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class CaptureTest < Minitest::Test
   include Liquid
 
   def test_captures_block_content_in_variable
-    assert_template_result('test string', "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
+    assert_template_result("test string", "{% capture 'var' %}test string{% endcapture %}{{var}}", {})
   end
 
   def test_capture_with_hyphen_in_variable_name
@@ -16,7 +14,7 @@ class CaptureTest < Minitest::Test
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal 'Print this-thing', rendered.strip
+    assert_equal "Print this-thing", rendered.strip
   end
 
   def test_capture_to_variable_from_outer_scope_if_existing
@@ -32,7 +30,7 @@ class CaptureTest < Minitest::Test
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal 'test-string', rendered.gsub(/\s/, '')
+    assert_equal "test-string", rendered.gsub(/\s/, '')
   end
 
   def test_assigning_from_capture
@@ -47,6 +45,6 @@ class CaptureTest < Minitest::Test
     END_TEMPLATE
     template = Template.parse(template_source)
     rendered = template.render!
-    assert_equal '3-3', rendered.gsub(/\s/, '')
+    assert_equal "3-3", rendered.gsub(/\s/, '')
   end
 end # CaptureTest

test/integration/context_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class ContextTest < Minitest::Test

test/integration/document_test.rb

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

test/integration/drop_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class ContextDrop < Liquid::Drop
@@ -23,7 +21,7 @@ end
 class ProductDrop < Liquid::Drop
   class TextDrop < Liquid::Drop
     def array
-      %w[text1 text2]
+      ['text1', 'text2']
     end
 
     def text
@@ -33,7 +31,7 @@ class ProductDrop < Liquid::Drop
 
   class CatchallDrop < Liquid::Drop
     def liquid_method_missing(method)
-      +'catchall_method: ' << method.to_s
+      'catchall_method: ' << method.to_s
     end
   end
 
@@ -50,13 +48,13 @@ class ProductDrop < Liquid::Drop
   end
 
   def user_input
-    (+'foo').taint
+    "foo".taint
   end
 
   protected
 
   def callmenot
-    'protected'
+    "protected"
   end
 end
 
@@ -141,17 +139,17 @@ class DropsTest < Minitest::Test
   end
 
   def test_drop_does_only_respond_to_whitelisted_methods
-    assert_equal '', Liquid::Template.parse('{{ product.inspect }}').render!('product' => ProductDrop.new)
-    assert_equal '', Liquid::Template.parse('{{ product.pretty_inspect }}').render!('product' => ProductDrop.new)
-    assert_equal '', Liquid::Template.parse('{{ product.whatever }}').render!('product' => ProductDrop.new)
-    assert_equal '', Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal '', Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
-    assert_equal '', Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse("{{ product.whatever }}").render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "pretty_inspect" }}').render!('product' => ProductDrop.new)
+    assert_equal "", Liquid::Template.parse('{{ product | map: "whatever" }}').render!('product' => ProductDrop.new)
   end
 
   def test_drops_respond_to_to_liquid
-    assert_equal 'text1', Liquid::Template.parse('{{ product.to_liquid.texts.text }}').render!('product' => ProductDrop.new)
-    assert_equal 'text1', Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
+    assert_equal "text1", Liquid::Template.parse("{{ product.to_liquid.texts.text }}").render!('product' => ProductDrop.new)
+    assert_equal "text1", Liquid::Template.parse('{{ product | map: "to_liquid" | map: "texts" | map: "text" }}').render!('product' => ProductDrop.new)
   end
 
   def test_text_drop
@@ -175,12 +173,12 @@ class DropsTest < Minitest::Test
   end
 
   def test_context_drop
-    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => 'carrot')
+    output = Liquid::Template.parse(' {{ context.bar }} ').render!('context' => ContextDrop.new, 'bar' => "carrot")
     assert_equal ' carrot ', output
   end
 
   def test_nested_context_drop
-    output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => 'monkey')
+    output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
     assert_equal ' monkey ', output
   end
 
@@ -190,7 +188,7 @@ class DropsTest < Minitest::Test
   end
 
   def test_object_methods_not_allowed
-    %i[dup clone singleton_class eval class_eval inspect].each do |method|
+    [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method|
       output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new)
       assert_equal '  ', output
     end
@@ -234,7 +232,7 @@ class DropsTest < Minitest::Test
   end
 
   def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
-    %w[select each map cycle].each do |method|
+    ["select", "each", "map", "cycle"].each do |method|
       assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
       assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
       assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
@@ -243,20 +241,20 @@ class DropsTest < Minitest::Test
   end
 
   def test_some_enumerable_methods_still_get_invoked
-    %i[count max].each do |method|
-      assert_equal '3', Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal '3', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal '3', Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal '3', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+    [:count, :max].each do |method|
+      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
+      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
     end
 
-    assert_equal 'yes', Liquid::Template.parse('{% if collection contains 3 %}yes{% endif %}').render!('collection' => RealEnumerableDrop.new)
+    assert_equal "yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new)
 
-    %i[min first].each do |method|
-      assert_equal '1', Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal '1', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal '1', Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal '1', Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+    [:min, :first].each do |method|
+      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
+      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
     end
   end
 
@@ -269,7 +267,7 @@ class DropsTest < Minitest::Test
   end
 
   def test_default_to_s_on_drops
-    assert_equal 'ProductDrop', Liquid::Template.parse('{{ product }}').render!('product' => ProductDrop.new)
+    assert_equal 'ProductDrop', Liquid::Template.parse("{{ product }}").render!('product' => ProductDrop.new)
     assert_equal 'EnumerableDrop', Liquid::Template.parse('{{ collection }}').render!('collection' => EnumerableDrop.new)
   end
 end # DropsTest

test/integration/error_handling_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class ErrorHandlingTest < Minitest::Test
@@ -92,7 +90,7 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
         ',
-                             line_numbers: true)
+        line_numbers: true)
     end
 
     assert_match(/Liquid syntax error \(line 4\)/, err.message)
@@ -107,7 +105,7 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
         ',
-                             line_numbers: true)
+        line_numbers: true)
     end
 
     assert_match(/Liquid syntax error \(line 4\)/, err.message)
@@ -121,11 +119,11 @@ class ErrorHandlingTest < Minitest::Test
 
         bla
             ',
-                                      error_mode: :warn,
-                                      line_numbers: true)
+      error_mode: :warn,
+      line_numbers: true)
 
     assert_equal ['Liquid syntax error (line 4): Unexpected character = in "1 =! 2"'],
-                 template.warnings.map(&:message)
+      template.warnings.map(&:message)
   end
 
   def test_parsing_strict_with_line_numbers_adds_numbers_to_lexer_errors
@@ -137,8 +135,8 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
                 ',
-                             error_mode: :strict,
-                             line_numbers: true)
+        error_mode: :strict,
+        line_numbers: true)
     end
 
     assert_equal 'Liquid syntax error (line 4): Unexpected character = in "1 =! 2"', err.message
@@ -155,7 +153,7 @@ class ErrorHandlingTest < Minitest::Test
 
           bla
                 ',
-                             line_numbers: true)
+        line_numbers: true)
     end
 
     assert_equal "Liquid syntax error (line 5): Unknown tag 'foo'", err.message
@@ -211,10 +209,7 @@ class ErrorHandlingTest < Minitest::Test
   def test_setting_default_exception_renderer
     old_exception_renderer = Liquid::Template.default_exception_renderer
     exceptions = []
-    Liquid::Template.default_exception_renderer = lambda { |e|
-      exceptions << e
-      ''
-    }
+    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)
@@ -228,10 +223,7 @@ class ErrorHandlingTest < Minitest::Test
   def test_exception_renderer_exposing_non_liquid_error
     template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
     exceptions = []
-    handler = lambda { |e|
-      exceptions << e
-      e.cause
-    }
+    handler = ->(e) { exceptions << e; e.cause }
 
     output = template.render({ 'errors' => ErrorDrop.new }, exception_renderer: handler)
 
@@ -243,7 +235,7 @@ class ErrorHandlingTest < Minitest::Test
 
   class TestFileSystem
     def read_template_file(_template_path)
-      '{{ errors.argument_error }}'
+      "{{ errors.argument_error }}"
     end
   end
 
@@ -258,6 +250,6 @@ class ErrorHandlingTest < Minitest::Test
       Liquid::Template.file_system = old_file_system
     end
     assert_equal "Argument error:\nLiquid error (product line 1): argument error", page
-    assert_equal 'product', template.errors.first.template_name
+    assert_equal "product", template.errors.first.template_name
   end
 end

test/integration/filter_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 module MoneyFilter
@@ -29,7 +27,7 @@ class FiltersTest < Minitest::Test
 
   module OverrideObjectMethodFilter
     def tap(_input)
-      'tap overridden'
+      "tap overridden"
     end
   end
 
@@ -41,13 +39,13 @@ class FiltersTest < Minitest::Test
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
 
-    assert_equal ' 1000$ ', Template.parse('{{var | money}}').render(@context)
+    assert_equal ' 1000$ ', Template.parse("{{var | money}}").render(@context)
   end
 
   def test_underscore_in_filter_name
     @context['var'] = 1000
     @context.add_filters(MoneyFilter)
-    assert_equal ' 1000$ ', Template.parse('{{var | money_with_underscore}}').render(@context)
+    assert_equal ' 1000$ ', Template.parse("{{var | money_with_underscore}}").render(@context)
   end
 
   def test_second_filter_overwrites_first
@@ -55,43 +53,43 @@ class FiltersTest < Minitest::Test
     @context.add_filters(MoneyFilter)
     @context.add_filters(CanadianMoneyFilter)
 
-    assert_equal ' 1000$ CAD ', Template.parse('{{var | money}}').render(@context)
+    assert_equal ' 1000$ CAD ', Template.parse("{{var | money}}").render(@context)
   end
 
   def test_size
     @context['var'] = 'abcd'
     @context.add_filters(MoneyFilter)
 
-    assert_equal '4', Template.parse('{{var | size}}').render(@context)
+    assert_equal '4', Template.parse("{{var | size}}").render(@context)
   end
 
   def test_join
     @context['var'] = [1, 2, 3, 4]
 
-    assert_equal '1 2 3 4', Template.parse('{{var | join}}').render(@context)
+    assert_equal "1 2 3 4", Template.parse("{{var | join}}").render(@context)
   end
 
   def test_sort
     @context['value'] = 3
     @context['numbers'] = [2, 1, 4, 3]
-    @context['words'] = %w[expected as alphabetic]
-    @context['arrays'] = %w[flower are]
-    @context['case_sensitive'] = %w[sensitive Expected case]
+    @context['words'] = ['expected', 'as', 'alphabetic']
+    @context['arrays'] = ['flower', 'are']
+    @context['case_sensitive'] = ['sensitive', 'Expected', 'case']
 
-    assert_equal '1 2 3 4', Template.parse('{{numbers | sort | join}}').render(@context)
-    assert_equal 'alphabetic as expected', Template.parse('{{words | sort | join}}').render(@context)
-    assert_equal '3', Template.parse('{{value | sort}}').render(@context)
-    assert_equal 'are flower', Template.parse('{{arrays | sort | join}}').render(@context)
-    assert_equal 'Expected case sensitive', Template.parse('{{case_sensitive | sort | join}}').render(@context)
+    assert_equal '1 2 3 4', Template.parse("{{numbers | sort | join}}").render(@context)
+    assert_equal 'alphabetic as expected', Template.parse("{{words | sort | join}}").render(@context)
+    assert_equal '3', Template.parse("{{value | sort}}").render(@context)
+    assert_equal 'are flower', Template.parse("{{arrays | sort | join}}").render(@context)
+    assert_equal 'Expected case sensitive', Template.parse("{{case_sensitive | sort | join}}").render(@context)
   end
 
   def test_sort_natural
-    @context['words'] = %w[case Assert Insensitive]
+    @context['words'] = ['case', 'Assert', 'Insensitive']
     @context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
     @context['objects'] = [TestObject.new('A'), TestObject.new('b'), TestObject.new('C')]
 
     # Test strings
-    assert_equal 'Assert case Insensitive', Template.parse('{{words | sort_natural | join}}').render(@context)
+    assert_equal 'Assert case Insensitive', Template.parse("{{words | sort_natural | join}}").render(@context)
 
     # Test hashes
     assert_equal 'A b C', Template.parse("{{hashes | sort_natural: 'a' | map: 'a' | join}}").render(@context)
@@ -106,7 +104,7 @@ class FiltersTest < Minitest::Test
     @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
 
     # Test strings
-    assert_equal 'a b c', Template.parse('{{words | compact | join}}').render(@context)
+    assert_equal 'a b c', Template.parse("{{words | compact | join}}").render(@context)
 
     # Test hashes
     assert_equal 'A C', Template.parse("{{hashes | compact: 'a' | map: 'a' | join}}").render(@context)
@@ -116,27 +114,27 @@ class FiltersTest < Minitest::Test
   end
 
   def test_strip_html
-    @context['var'] = '<b>bla blub</a>'
+    @context['var'] = "<b>bla blub</a>"
 
-    assert_equal 'bla blub', Template.parse('{{ var | strip_html }}').render(@context)
+    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
   end
 
   def test_strip_html_ignore_comments_with_html
-    @context['var'] = '<!-- split and some <ul> tag --><b>bla blub</a>'
+    @context['var'] = "<!-- split and some <ul> tag --><b>bla blub</a>"
 
-    assert_equal 'bla blub', Template.parse('{{ var | strip_html }}').render(@context)
+    assert_equal "bla blub", Template.parse("{{ var | strip_html }}").render(@context)
   end
 
   def test_capitalize
-    @context['var'] = 'blub'
+    @context['var'] = "blub"
 
-    assert_equal 'Blub', Template.parse('{{ var | capitalize }}').render(@context)
+    assert_equal "Blub", Template.parse("{{ var | capitalize }}").render(@context)
   end
 
   def test_nonexistent_filter_is_ignored
     @context['var'] = 1000
 
-    assert_equal '1000', Template.parse('{{ var | xyzzy }}').render(@context)
+    assert_equal '1000', Template.parse("{{ var | xyzzy }}").render(@context)
   end
 
   def test_filter_with_keyword_arguments
@@ -148,10 +146,10 @@ class FiltersTest < Minitest::Test
   end
 
   def test_override_object_method_in_filter
-    assert_equal 'tap overridden', Template.parse('{{var | tap}}').render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
+    assert_equal "tap overridden", Template.parse("{{var | tap}}").render!({ 'var' => 1000 }, filters: [OverrideObjectMethodFilter])
 
     # tap still treated as a non-existent filter
-    assert_equal '1000', Template.parse('{{var | tap}}').render!('var' => 1000)
+    assert_equal "1000", Template.parse("{{var | tap}}").render!('var' => 1000)
   end
 end
 
@@ -160,15 +158,15 @@ class FiltersInTemplate < Minitest::Test
 
   def test_local_global
     with_global_filter(MoneyFilter) do
-      assert_equal ' 1000$ ', Template.parse('{{1000 | money}}').render!(nil, nil)
-      assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, filters: CanadianMoneyFilter)
-      assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, filters: [CanadianMoneyFilter])
+      assert_equal " 1000$ ", Template.parse("{{1000 | money}}").render!(nil, nil)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: CanadianMoneyFilter)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, filters: [CanadianMoneyFilter])
     end
   end
 
   def test_local_filter_with_deprecated_syntax
-    assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, CanadianMoneyFilter)
-    assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render!(nil, [CanadianMoneyFilter])
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, CanadianMoneyFilter)
+    assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render!(nil, [CanadianMoneyFilter])
   end
 end # FiltersTest
 

test/integration/hash_ordering_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class HashOrderingTest < Minitest::Test
@@ -19,7 +17,7 @@ class HashOrderingTest < Minitest::Test
 
   def test_global_register_order
     with_global_filter(MoneyFilter, CanadianMoneyFilter) do
-      assert_equal ' 1000$ CAD ', Template.parse('{{1000 | money}}').render(nil, nil)
+      assert_equal " 1000$ CAD ", Template.parse("{{1000 | money}}").render(nil, nil)
     end
   end
 end

test/integration/legacy_test.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-require 'liquid/legacy'
-
-class FiltersTest < Minitest::Test
-  include Liquid
-
-  def test_constants
-    assert_equal Liquid::FilterSeparator, Liquid::FILTER_SEPARATOR
-    assert_equal Liquid::BlockBody::ContentOfVariable, Liquid::BlockBody::CONTENT_OF_VARIABLE
-  end
-end

test/integration/output_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 module FunnyFilter
@@ -11,11 +9,11 @@ module FunnyFilter
     "LOL: #{input}"
   end
 
-  def add_smiley(input, smiley = ':-)')
+  def add_smiley(input, smiley = ":-)")
     "#{input} #{smiley}"
   end
 
-  def add_tag(input, tag = 'p', id = 'foo')
+  def add_tag(input, tag = "p", id = "foo")
     %(<#{tag} id="#{id}">#{input}</#{tag}>)
   end
 
@@ -47,9 +45,9 @@ class OutputTest < Minitest::Test
 
   def test_variable_traversing_with_two_brackets
     text = %({{ site.data.menu[include.menu][include.locale] }})
-    assert_equal 'it works!', Template.parse(text).render!(
-      'site' => { 'data' => { 'menu' => { 'foo' => { 'bar' => 'it works!' } } } },
-      'include' => { 'menu' => 'foo', 'locale' => 'bar' }
+    assert_equal "it works!", Template.parse(text).render!(
+      "site" => { "data" => { "menu" => { "foo" => { "bar" => "it works!" } } } },
+      "include" => { "menu" => "foo", "locale" => "bar" }
     )
   end
 

test/integration/parse_tree_visitor_test.rb

@@ -7,217 +7,217 @@ class ParseTreeVisitorTest < Minitest::Test
 
   def test_variable
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({{ test }}))
     )
   end
 
   def test_varible_with_filter
     assert_equal(
-      %w[test infilter],
+      ["test", "infilter"],
       visit(%({{ test | split: infilter }}))
     )
   end
 
   def test_dynamic_variable
     assert_equal(
-      %w[test inlookup],
+      ["test", "inlookup"],
       visit(%({{ test[inlookup] }}))
     )
   end
 
   def test_if_condition
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% if test %}{% endif %}))
     )
   end
 
   def test_complex_if_condition
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% if 1 == 1 and 2 == test %}{% endif %}))
     )
   end
 
   def test_if_body
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% if 1 == 1 %}{{ test }}{% endif %}))
     )
   end
 
   def test_unless_condition
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% unless test %}{% endunless %}))
     )
   end
 
   def test_complex_unless_condition
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% unless 1 == 1 and 2 == test %}{% endunless %}))
     )
   end
 
   def test_unless_body
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% unless 1 == 1 %}{{ test }}{% endunless %}))
     )
   end
 
   def test_elsif_condition
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% if 1 == 1 %}{% elsif test %}{% endif %}))
     )
   end
 
   def test_complex_elsif_condition
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% if 1 == 1 %}{% elsif 1 == 1 and 2 == test %}{% endif %}))
     )
   end
 
   def test_elsif_body
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% if 1 == 1 %}{% elsif 2 == 2 %}{{ test }}{% endif %}))
     )
   end
 
   def test_else_body
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% if 1 == 1 %}{% else %}{{ test }}{% endif %}))
     )
   end
 
   def test_case_left
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% case test %}{% endcase %}))
     )
   end
 
   def test_case_condition
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% case 1 %}{% when test %}{% endcase %}))
     )
   end
 
   def test_case_when_body
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% case 1 %}{% when 2 %}{{ test }}{% endcase %}))
     )
   end
 
   def test_case_else_body
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% case 1 %}{% else %}{{ test }}{% endcase %}))
     )
   end
 
   def test_for_in
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% for x in test %}{% endfor %}))
     )
   end
 
   def test_for_limit
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% for x in (1..5) limit: test %}{% endfor %}))
     )
   end
 
   def test_for_offset
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% for x in (1..5) offset: test %}{% endfor %}))
     )
   end
 
   def test_for_body
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% for x in (1..5) %}{{ test }}{% endfor %}))
     )
   end
 
   def test_tablerow_in
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% tablerow x in test %}{% endtablerow %}))
     )
   end
 
   def test_tablerow_limit
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% tablerow x in (1..5) limit: test %}{% endtablerow %}))
     )
   end
 
   def test_tablerow_offset
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% tablerow x in (1..5) offset: test %}{% endtablerow %}))
     )
   end
 
   def test_tablerow_body
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% tablerow x in (1..5) %}{{ test }}{% endtablerow %}))
     )
   end
 
   def test_cycle
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% cycle test %}))
     )
   end
 
   def test_assign
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% assign x = test %}))
     )
   end
 
   def test_capture
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% capture x %}{{ test }}{% endcapture %}))
     )
   end
 
   def test_include
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% include test %}))
     )
   end
 
   def test_include_with
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% include "hai" with test %}))
     )
   end
 
   def test_include_for
     assert_equal(
-      ['test'],
+      ["test"],
       visit(%({% include "hai" for test %}))
     )
   end
@@ -225,9 +225,9 @@ class ParseTreeVisitorTest < Minitest::Test
   def test_preserve_tree_structure
     assert_equal(
       [[nil, [
-        [nil, [[nil, [['other', []]]]]],
-        ['test', []],
-        ['xs', []],
+        [nil, [[nil, [["other", []]]]]],
+        ["test", []],
+        ["xs", []],
       ]]],
       traversal(%({% for x in xs offset: test %}{{ other }}{% endfor %})).visit
     )

test/integration/parsing_quirks_test.rb

@@ -1,43 +1,41 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class ParsingQuirksTest < Minitest::Test
   include Liquid
 
   def test_parsing_css
-    text = ' div { font-weight: bold; } '
+    text = " div { font-weight: bold; } "
     assert_equal text, Template.parse(text).render!
   end
 
   def test_raise_on_single_close_bracet
     assert_raises(SyntaxError) do
-      Template.parse('text {{method} oh nos!')
+      Template.parse("text {{method} oh nos!")
     end
   end
 
   def test_raise_on_label_and_no_close_bracets
     assert_raises(SyntaxError) do
-      Template.parse('TEST {{ ')
+      Template.parse("TEST {{ ")
     end
   end
 
   def test_raise_on_label_and_no_close_bracets_percent
     assert_raises(SyntaxError) do
-      Template.parse('TEST {% ')
+      Template.parse("TEST {% ")
     end
   end
 
   def test_error_on_empty_filter
-    assert Template.parse('{{test}}')
+    assert Template.parse("{{test}}")
 
     with_error_mode(:lax) do
-      assert Template.parse('{{|test}}')
+      assert Template.parse("{{|test}}")
     end
 
     with_error_mode(:strict) do
-      assert_raises(SyntaxError) { Template.parse('{{|test}}') }
-      assert_raises(SyntaxError) { Template.parse('{{test |a|b|}}') }
+      assert_raises(SyntaxError) { Template.parse("{{|test}}") }
+      assert_raises(SyntaxError) { Template.parse("{{test |a|b|}}") }
     end
   end
 
@@ -53,20 +51,20 @@ class ParsingQuirksTest < Minitest::Test
   def test_unexpected_characters_syntax_error
     with_error_mode(:strict) do
       assert_raises(SyntaxError) do
-        markup = 'true && false'
+        markup = "true && false"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
       assert_raises(SyntaxError) do
-        markup = 'false || true'
+        markup = "false || true"
         Template.parse("{% if #{markup} %} YES {% endif %}")
       end
     end
   end
 
   def test_no_error_on_lax_empty_filter
-    assert Template.parse('{{test |a|b|}}', error_mode: :lax)
-    assert Template.parse('{{test}}', error_mode: :lax)
-    assert Template.parse('{{|test|}}', error_mode: :lax)
+    assert Template.parse("{{test |a|b|}}", error_mode: :lax)
+    assert Template.parse("{{test}}", error_mode: :lax)
+    assert Template.parse("{{|test|}}", error_mode: :lax)
   end
 
   def test_meaningless_parens_lax
@@ -79,9 +77,9 @@ class ParsingQuirksTest < Minitest::Test
 
   def test_unexpected_characters_silently_eat_logic_lax
     with_error_mode(:lax) do
-      markup = 'true && false'
+      markup = "true && false"
       assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}")
-      markup = 'false || true'
+      markup = "false || true"
       assert_template_result('', "{% if #{markup} %} YES {% endif %}")
     end
   end
@@ -114,7 +112,7 @@ class ParsingQuirksTest < Minitest::Test
 
   def test_extra_dots_in_ranges
     with_error_mode(:lax) do
-      assert_template_result('12345', '{% for i in (1...5) %}{{ i }}{% endfor %}')
+      assert_template_result('12345', "{% for i in (1...5) %}{{ i }}{% endfor %}")
     end
   end
 

test/integration/render_profiling_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class RenderProfilingTest < Minitest::Test
@@ -74,7 +72,7 @@ class RenderProfilingTest < Minitest::Test
     t = Template.parse("{% include 'a_template' %}", profile: true)
     t.render!
 
-    assert t.profiler.total_render_time >= 0, 'Total render time was not calculated'
+    assert t.profiler.total_render_time >= 0, "Total render time was not calculated"
   end
 
   def test_profiling_uses_include_to_mark_children
@@ -91,7 +89,7 @@ class RenderProfilingTest < Minitest::Test
 
     include_node = t.profiler[1]
     include_node.children.each do |child|
-      assert_equal 'a_template', child.partial
+      assert_equal "a_template", child.partial
     end
   end
 
@@ -101,12 +99,12 @@ class RenderProfilingTest < Minitest::Test
 
     a_template = t.profiler[1]
     a_template.children.each do |child|
-      assert_equal 'a_template', child.partial
+      assert_equal "a_template", child.partial
     end
 
     b_template = t.profiler[2]
     b_template.children.each do |child|
-      assert_equal 'b_template', child.partial
+      assert_equal "b_template", child.partial
     end
   end
 
@@ -116,12 +114,12 @@ class RenderProfilingTest < Minitest::Test
 
     a_template1 = t.profiler[1]
     a_template1.children.each do |child|
-      assert_equal 'a_template', child.partial
+      assert_equal "a_template", child.partial
     end
 
     a_template2 = t.profiler[2]
     a_template2.children.each do |child|
-      assert_equal 'a_template', child.partial
+      assert_equal "a_template", child.partial
     end
   end
 
@@ -138,7 +136,7 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_marks_children_of_if_blocks
-    t = Template.parse('{% if true %} {% increment test %} {{ test }} {% endif %}', profile: true)
+    t = Template.parse("{% if true %} {% increment test %} {{ test }} {% endif %}", profile: true)
     t.render!
 
     assert_equal 1, t.profiler.length
@@ -146,8 +144,8 @@ class RenderProfilingTest < Minitest::Test
   end
 
   def test_profiling_marks_children_of_for_blocks
-    t = Template.parse('{% for item in collection %} {{ item }} {% endfor %}', profile: true)
-    t.render!('collection' => %w[one two])
+    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
+    t.render!("collection" => ["one", "two"])
 
     assert_equal 1, t.profiler.length
     # Will profile each invocation of the for block

test/integration/security_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 module SecurityFilter
@@ -59,22 +57,22 @@ class SecurityTest < Minitest::Test
     current_symbols = Symbol.all_symbols
 
     assigns = { 'drop' => Drop.new }
-    assert_equal '', Template.parse('{{ drop.custom_method_1 }}', assigns).render!
-    assert_equal '', Template.parse('{{ drop.custom_method_2 }}', assigns).render!
-    assert_equal '', Template.parse('{{ drop.custom_method_3 }}', assigns).render!
+    assert_equal "", Template.parse("{{ drop.custom_method_1 }}", assigns).render!
+    assert_equal "", Template.parse("{{ drop.custom_method_2 }}", assigns).render!
+    assert_equal "", Template.parse("{{ drop.custom_method_3 }}", assigns).render!
 
     assert_equal [], (Symbol.all_symbols - current_symbols)
   end
 
   def test_max_depth_nested_blocks_does_not_raise_exception
     depth = Liquid::Block::MAX_DEPTH
-    code = '{% if true %}' * depth + 'rendered' + '{% endif %}' * depth
-    assert_equal 'rendered', Template.parse(code).render!
+    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
+    assert_equal "rendered", Template.parse(code).render!
   end
 
   def test_more_than_max_depth_nested_blocks_raises_exception
     depth = Liquid::Block::MAX_DEPTH + 1
-    code = '{% if true %}' * depth + 'rendered' + '{% endif %}' * depth
+    code = "{% if true %}" * depth + "rendered" + "{% endif %}" * depth
     assert_raises(Liquid::StackLevelError) do
       Template.parse(code).render!
     end

test/integration/standard_filter_test.rb

@@ -1,4 +1,4 @@
-# frozen_string_literal: true
+# encoding: utf-8
 
 require 'test_helper'
 
@@ -29,7 +29,7 @@ end
 
 class TestDrop < Liquid::Drop
   def test
-    'testfoo'
+    "testfoo"
   end
 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
 
@@ -65,12 +65,12 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_downcase
-    assert_equal 'testing', @filters.downcase('Testing')
+    assert_equal 'testing', @filters.downcase("Testing")
     assert_equal '', @filters.downcase(nil)
   end
 
   def test_upcase
-    assert_equal 'TESTING', @filters.upcase('Testing')
+    assert_equal 'TESTING', @filters.upcase("Testing")
     assert_equal '', @filters.upcase(nil)
   end
 
@@ -91,22 +91,22 @@ class StandardFiltersTest < Minitest::Test
       @filters.slice('foobar', nil)
     end
     assert_raises(Liquid::ArgumentError) do
-      @filters.slice('foobar', 0, '')
+      @filters.slice('foobar', 0, "")
     end
   end
 
   def test_slice_on_arrays
     input = 'foobar'.split(//)
-    assert_equal %w[o o b], @filters.slice(input, 1, 3)
-    assert_equal %w[o o b a r], @filters.slice(input, 1, 1000)
-    assert_equal %w[], @filters.slice(input, 1, 0)
-    assert_equal %w[o], @filters.slice(input, 1, 1)
-    assert_equal %w[b a r], @filters.slice(input, 3, 3)
-    assert_equal %w[a r], @filters.slice(input, -2, 2)
-    assert_equal %w[a r], @filters.slice(input, -2, 1000)
-    assert_equal %w[r], @filters.slice(input, -1)
-    assert_equal %w[], @filters.slice(input, 100, 10)
-    assert_equal %w[], @filters.slice(input, -100, 10)
+    assert_equal %w(o o b), @filters.slice(input, 1, 3)
+    assert_equal %w(o o b a r), @filters.slice(input, 1, 1000)
+    assert_equal %w(), @filters.slice(input, 1, 0)
+    assert_equal %w(o), @filters.slice(input, 1, 1)
+    assert_equal %w(b a r), @filters.slice(input, 3, 3)
+    assert_equal %w(a r), @filters.slice(input, -2, 2)
+    assert_equal %w(a r), @filters.slice(input, -2, 1000)
+    assert_equal %w(r), @filters.slice(input, -1)
+    assert_equal %w(), @filters.slice(input, 100, 10)
+    assert_equal %w(), @filters.slice(input, -100, 10)
   end
 
   def test_truncate
@@ -114,16 +114,16 @@ class StandardFiltersTest < Minitest::Test
     assert_equal '1234567890', @filters.truncate('1234567890', 20)
     assert_equal '...', @filters.truncate('1234567890', 0)
     assert_equal '1234567890', @filters.truncate('1234567890')
-    assert_equal '测试...', @filters.truncate('测试测试测试测试', 5)
-    assert_equal '12341', @filters.truncate('1234567890', 5, 1)
+    assert_equal "测试...", @filters.truncate("测试测试测试测试", 5)
+    assert_equal '12341', @filters.truncate("1234567890", 5, 1)
   end
 
   def test_split
-    assert_equal %w[12 34], @filters.split('12~34', '~')
+    assert_equal ['12', '34'], @filters.split('12~34', '~')
     assert_equal ['A? ', ' ,Z'], @filters.split('A? ~ ~ ~ ,Z', '~ ~ ~')
     assert_equal ['A?Z'], @filters.split('A?Z', '~')
     assert_equal [], @filters.split(nil, ' ')
-    assert_equal %w[A Z], @filters.split('A1Z', 1)
+    assert_equal ['A', 'Z'], @filters.split('A1Z', 1)
   end
 
   def test_escape
@@ -169,12 +169,12 @@ class StandardFiltersTest < Minitest::Test
     assert_equal 'one two...', @filters.truncatewords('one two three', 2)
     assert_equal 'one two three', @filters.truncatewords('one two three')
     assert_equal 'Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221;...', @filters.truncatewords('Two small (13&#8221; x 5.5&#8221; x 10&#8221; high) baskets fit inside one large basket (13&#8221; x 16&#8221; x 10.5&#8221; high) with cover.', 15)
-    assert_equal '测试测试测试测试', @filters.truncatewords('测试测试测试测试', 5)
-    assert_equal 'one two1', @filters.truncatewords('one two three', 2, 1)
+    assert_equal "测试测试测试测试", @filters.truncatewords('测试测试测试测试', 5)
+    assert_equal 'one two1', @filters.truncatewords("one two three", 2, 1)
   end
 
   def test_strip_html
-    assert_equal 'test', @filters.strip_html('<div>test</div>')
+    assert_equal 'test', @filters.strip_html("<div>test</div>")
     assert_equal 'test', @filters.strip_html("<div id='test'>test</div>")
     assert_equal '', @filters.strip_html("<script type='text/javascript'>document.write('some stuff');</script>")
     assert_equal '', @filters.strip_html("<style type='text/css'>foo bar</style>")
@@ -183,7 +183,7 @@ class StandardFiltersTest < Minitest::Test
     assert_equal '', @filters.strip_html(nil)
 
     # Quirk of the existing implementation
-    assert_equal 'foo;', @filters.strip_html('<<<script </script>script>foo;</script>')
+    assert_equal 'foo;', @filters.strip_html("<<<script </script>script>foo;</script>")
   end
 
   def test_join
@@ -194,85 +194,85 @@ class StandardFiltersTest < Minitest::Test
 
   def test_sort
     assert_equal [1, 2, 3, 4], @filters.sort([4, 3, 2, 1])
-    assert_equal [{ 'a' => 1 }, { 'a' => 2 }, { 'a' => 3 }, { 'a' => 4 }], @filters.sort([{ 'a' => 4 }, { 'a' => 3 }, { 'a' => 1 }, { 'a' => 2 }], 'a')
+    assert_equal [{ "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')
+    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" => 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' },
+      { "price" => 1, "handle" => "gamma" },
+      { "price" => 2, "handle" => "epsilon" },
+      { "price" => 4, "handle" => "alpha" },
+      { "handle" => "delta" },
+      { "handle" => "beta" },
     ]
-    assert_equal expectation, @filters.sort(input, 'price')
+    assert_equal expectation, @filters.sort(input, "price")
   end
 
   def test_sort_natural
-    assert_equal %w[a B c D], @filters.sort_natural(%w[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')
+    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')
+    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' },
+      { "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' },
+      { "price" => "1", "handle" => "gamma" },
+      { "price" => 2, "handle" => "epsilon" },
+      { "price" => "4", "handle" => "alpha" },
+      { "handle" => "delta" },
+      { "handle" => "beta" },
     ]
-    assert_equal expectation, @filters.sort_natural(input, 'price')
+    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' },
+      { "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' },
+      { "key" => "a" },
+      { "key" => "b" },
+      { "key" => "c" },
+      { "key" => "X" },
+      { "key" => "Y" },
+      { "key" => "Z" },
+      { "fake" => "t" },
     ]
-    assert_equal expectation, @filters.sort_natural(input, 'key')
-    assert_equal %w[a b c X Y Z], @filters.sort_natural(%w[X Y Z a b c])
+    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')
+    assert_equal [], @filters.sort([], "a")
   end
 
   def test_sort_invalid_property
@@ -283,12 +283,12 @@ class StandardFiltersTest < Minitest::Test
     ]
 
     assert_raises Liquid::ArgumentError do
-      @filters.sort(foo, 'bar')
+      @filters.sort(foo, "bar")
     end
   end
 
   def test_sort_natural_empty_array
-    assert_equal [], @filters.sort_natural([], 'a')
+    assert_equal [], @filters.sort_natural([], "a")
   end
 
   def test_sort_natural_invalid_property
@@ -299,7 +299,7 @@ class StandardFiltersTest < Minitest::Test
     ]
 
     assert_raises Liquid::ArgumentError do
-      @filters.sort_natural(foo, 'bar')
+      @filters.sort_natural(foo, "bar")
     end
   end
 
@@ -309,21 +309,21 @@ class StandardFiltersTest < Minitest::Test
 
   def test_numerical_vs_lexicographical_sort
     assert_equal [2, 10], @filters.sort([10, 2])
-    assert_equal [{ 'a' => 2 }, { 'a' => 10 }], @filters.sort([{ 'a' => 10 }, { 'a' => 2 }], 'a')
-    assert_equal %w[10 2], @filters.sort(%w[10 2])
-    assert_equal [{ 'a' => '10' }, { 'a' => '2' }], @filters.sort([{ 'a' => '10' }, { 'a' => '2' }], 'a')
+    assert_equal [{ "a" => 2 }, { "a" => 10 }], @filters.sort([{ "a" => 10 }, { "a" => 2 }], "a")
+    assert_equal ["10", "2"], @filters.sort(["10", "2"])
+    assert_equal [{ "a" => "10" }, { "a" => "2" }], @filters.sort([{ "a" => "10" }, { "a" => "2" }], "a")
   end
 
   def test_uniq
-    assert_equal ['foo'], @filters.uniq('foo')
+    assert_equal ["foo"], @filters.uniq("foo")
     assert_equal [1, 3, 2, 4], @filters.uniq([1, 1, 3, 2, 3, 1, 4, 3, 2, 1])
-    assert_equal [{ 'a' => 1 }, { 'a' => 3 }, { 'a' => 2 }], @filters.uniq([{ 'a' => 1 }, { 'a' => 3 }, { 'a' => 1 }, { 'a' => 2 }], 'a')
+    assert_equal [{ "a" => 1 }, { "a" => 3 }, { "a" => 2 }], @filters.uniq([{ "a" => 1 }, { "a" => 3 }, { "a" => 1 }, { "a" => 2 }], "a")
     testdrop = TestDrop.new
     assert_equal [testdrop], @filters.uniq([testdrop, TestDrop.new], 'test')
   end
 
   def test_uniq_empty_array
-    assert_equal [], @filters.uniq([], 'a')
+    assert_equal [], @filters.uniq([], "a")
   end
 
   def test_uniq_invalid_property
@@ -334,12 +334,12 @@ class StandardFiltersTest < Minitest::Test
     ]
 
     assert_raises Liquid::ArgumentError do
-      @filters.uniq(foo, 'bar')
+      @filters.uniq(foo, "bar")
     end
   end
 
   def test_compact_empty_array
-    assert_equal [], @filters.compact([], 'a')
+    assert_equal [], @filters.compact([], "a")
   end
 
   def test_compact_invalid_property
@@ -350,7 +350,7 @@ class StandardFiltersTest < Minitest::Test
     ]
 
     assert_raises Liquid::ArgumentError do
-      @filters.compact(foo, 'bar')
+      @filters.compact(foo, "bar")
     end
   end
 
@@ -363,60 +363,60 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_map
-    assert_equal [1, 2, 3, 4], @filters.map([{ 'a' => 1 }, { 'a' => 2 }, { 'a' => 3 }, { 'a' => 4 }], 'a')
+    assert_equal [1, 2, 3, 4], @filters.map([{ "a" => 1 }, { "a" => 2 }, { "a" => 3 }, { "a" => 4 }], 'a')
     assert_template_result 'abc', "{{ ary | map:'foo' | map:'bar' }}",
-                           'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }]
+      'ary' => [{ 'foo' => { 'bar' => 'a' } }, { 'foo' => { 'bar' => 'b' } }, { 'foo' => { 'bar' => 'c' } }]
   end
 
   def test_map_doesnt_call_arbitrary_stuff
-    assert_template_result '', '{{ "foo" | map: "__id__" }}'
-    assert_template_result '', '{{ "foo" | map: "inspect" }}'
+    assert_template_result "", '{{ "foo" | map: "__id__" }}'
+    assert_template_result "", '{{ "foo" | map: "inspect" }}'
   end
 
   def test_map_calls_to_liquid
     t = TestThing.new
-    assert_template_result 'woot: 1', '{{ foo | map: "whatever" }}', 'foo' => [t]
+    assert_template_result "woot: 1", '{{ foo | map: "whatever" }}', "foo" => [t]
   end
 
   def test_map_on_hashes
-    assert_template_result '4217', '{{ thing | map: "foo" | map: "bar" }}',
-                           'thing' => { 'foo' => [{ 'bar' => 42 }, { 'bar' => 17 }] }
+    assert_template_result "4217", '{{ thing | map: "foo" | map: "bar" }}',
+      "thing" => { "foo" => [{ "bar" => 42 }, { "bar" => 17 }] }
   end
 
   def test_legacy_map_on_hashes_with_dynamic_key
     template = "{% assign key = 'foo' %}{{ thing | map: key | map: 'bar' }}"
-    hash = { 'foo' => { 'bar' => 42 } }
-    assert_template_result '42', template, 'thing' => hash
+    hash = { "foo" => { "bar" => 42 } }
+    assert_template_result "42", template, "thing" => hash
   end
 
   def test_sort_calls_to_liquid
     t = TestThing.new
-    Liquid::Template.parse('{{ foo | sort: "whatever" }}').render('foo' => [t])
-    assert t.foo.positive?
+    Liquid::Template.parse('{{ foo | sort: "whatever" }}').render("foo" => [t])
+    assert t.foo > 0
   end
 
   def test_map_over_proc
     drop = TestDrop.new
     p = proc { drop }
     templ = '{{ procs | map: "test" }}'
-    assert_template_result 'testfoo', templ, 'procs' => [p]
+    assert_template_result "testfoo", templ, "procs" => [p]
   end
 
   def test_map_over_drops_returning_procs
     drops = [
       {
-        'proc' => -> { 'foo' },
+        "proc" => -> { "foo" },
       },
       {
-        'proc' => -> { 'bar' },
+        "proc" => -> { "bar" },
       },
     ]
     templ = '{{ drops | map: "proc" }}'
-    assert_template_result 'foobar', templ, 'drops' => drops
+    assert_template_result "foobar", templ, "drops" => drops
   end
 
   def test_map_works_on_enumerables
-    assert_template_result '123', '{{ foo | map: "foo" }}', 'foo' => TestEnumerable.new
+    assert_template_result "123", '{{ foo | map: "foo" }}', "foo" => TestEnumerable.new
   end
 
   def test_map_returns_empty_on_2d_input_array
@@ -427,7 +427,7 @@ class StandardFiltersTest < Minitest::Test
     ]
 
     assert_raises Liquid::ArgumentError do
-      @filters.map(foo, 'bar')
+      @filters.map(foo, "bar")
     end
   end
 
@@ -443,7 +443,7 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_sort_works_on_enumerables
-    assert_template_result '213', '{{ foo | sort: "bar" | map: "foo" }}', 'foo' => TestEnumerable.new
+    assert_template_result "213", '{{ foo | sort: "bar" | map: "foo" }}', "foo" => TestEnumerable.new
   end
 
   def test_first_and_last_call_to_liquid
@@ -452,37 +452,37 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_truncate_calls_to_liquid
-    assert_template_result 'wo...', '{{ foo | truncate: 5 }}', 'foo' => TestThing.new
+    assert_template_result "wo...", '{{ foo | truncate: 5 }}', "foo" => TestThing.new
   end
 
   def test_date
-    assert_equal 'May', @filters.date(Time.parse('2006-05-05 10:00:00'), '%B')
-    assert_equal 'June', @filters.date(Time.parse('2006-06-05 10:00:00'), '%B')
-    assert_equal 'July', @filters.date(Time.parse('2006-07-05 10:00:00'), '%B')
+    assert_equal 'May', @filters.date(Time.parse("2006-05-05 10:00:00"), "%B")
+    assert_equal 'June', @filters.date(Time.parse("2006-06-05 10:00:00"), "%B")
+    assert_equal 'July', @filters.date(Time.parse("2006-07-05 10:00:00"), "%B")
 
-    assert_equal 'May', @filters.date('2006-05-05 10:00:00', '%B')
-    assert_equal 'June', @filters.date('2006-06-05 10:00:00', '%B')
-    assert_equal 'July', @filters.date('2006-07-05 10:00:00', '%B')
+    assert_equal 'May', @filters.date("2006-05-05 10:00:00", "%B")
+    assert_equal 'June', @filters.date("2006-06-05 10:00:00", "%B")
+    assert_equal 'July', @filters.date("2006-07-05 10:00:00", "%B")
 
-    assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '')
-    assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '')
-    assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', '')
-    assert_equal '2006-07-05 10:00:00', @filters.date('2006-07-05 10:00:00', nil)
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", "")
+    assert_equal '2006-07-05 10:00:00', @filters.date("2006-07-05 10:00:00", nil)
 
-    assert_equal '07/05/2006', @filters.date('2006-07-05 10:00:00', '%m/%d/%Y')
+    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 "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.to_s, @filters.date('today', '%Y')
     assert_equal Date.today.year.to_s, @filters.date('Today', '%Y')
 
-    assert_nil @filters.date(nil, '%B')
+    assert_nil @filters.date(nil, "%B")
 
-    assert_equal '', @filters.date('', '%B')
+    assert_equal '', @filters.date('', "%B")
 
-    with_timezone('UTC') do
-      assert_equal '07/05/2006', @filters.date(1_152_098_955, '%m/%d/%Y')
-      assert_equal '07/05/2006', @filters.date('1152098955', '%m/%d/%Y')
+    with_timezone("UTC") do
+      assert_equal "07/05/2006", @filters.date(1152098955, "%m/%d/%Y")
+      assert_equal "07/05/2006", @filters.date("1152098955", "%m/%d/%Y")
     end
   end
 
@@ -502,10 +502,10 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_remove
-    assert_equal '   ', @filters.remove('a a a a', 'a')
-    assert_equal '   ', @filters.remove('1 1 1 1', 1)
-    assert_equal 'a a a', @filters.remove_first('a a a a', 'a ')
-    assert_equal ' 1 1 1', @filters.remove_first('1 1 1 1', 1)
+    assert_equal '   ', @filters.remove("a a a a", 'a')
+    assert_equal '   ', @filters.remove("1 1 1 1", 1)
+    assert_equal 'a a a', @filters.remove_first("a a a a", 'a ')
+    assert_equal ' 1 1 1', @filters.remove_first("1 1 1 1", 1)
     assert_template_result 'a a a', "{{ 'a a a a' | remove_first: 'a ' }}"
   end
 
@@ -514,148 +514,148 @@ class StandardFiltersTest < Minitest::Test
   end
 
   def test_strip
-    assert_template_result 'ab c', '{{ source | strip }}', 'source' => ' ab c  '
-    assert_template_result 'ab c', '{{ source | strip }}', 'source' => " \tab c  \n \t"
+    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " ab c  "
+    assert_template_result 'ab c', "{{ source | strip }}", 'source' => " \tab c  \n \t"
   end
 
   def test_lstrip
-    assert_template_result 'ab c  ', '{{ source | lstrip }}', 'source' => ' ab c  '
-    assert_template_result "ab c  \n \t", '{{ source | lstrip }}', 'source' => " \tab c  \n \t"
+    assert_template_result 'ab c  ', "{{ source | lstrip }}", 'source' => " ab c  "
+    assert_template_result "ab c  \n \t", "{{ source | lstrip }}", 'source' => " \tab c  \n \t"
   end
 
   def test_rstrip
-    assert_template_result ' ab c', '{{ source | rstrip }}', 'source' => ' ab c  '
-    assert_template_result " \tab c", '{{ source | rstrip }}', 'source' => " \tab c  \n \t"
+    assert_template_result " ab c", "{{ source | rstrip }}", 'source' => " ab c  "
+    assert_template_result " \tab c", "{{ source | rstrip }}", 'source' => " \tab c  \n \t"
   end
 
   def test_strip_newlines
-    assert_template_result 'abc', '{{ source | strip_newlines }}', 'source' => "a\nb\nc"
-    assert_template_result 'abc', '{{ source | strip_newlines }}', 'source' => "a\r\nb\nc"
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\nb\nc"
+    assert_template_result 'abc', "{{ source | strip_newlines }}", 'source' => "a\r\nb\nc"
   end
 
   def test_newlines_to_br
-    assert_template_result "a<br />\nb<br />\nc", '{{ source | newline_to_br }}', 'source' => "a\nb\nc"
+    assert_template_result "a<br />\nb<br />\nc", "{{ source | newline_to_br }}", 'source' => "a\nb\nc"
   end
 
   def test_plus
-    assert_template_result '2', '{{ 1 | plus:1 }}'
-    assert_template_result '2.0', "{{ '1' | plus:'1.0' }}"
+    assert_template_result "2", "{{ 1 | plus:1 }}"
+    assert_template_result "2.0", "{{ '1' | plus:'1.0' }}"
 
-    assert_template_result '5', "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3)
+    assert_template_result "5", "{{ price | plus:'2' }}", 'price' => NumberLikeThing.new(3)
   end
 
   def test_minus
-    assert_template_result '4', '{{ input | minus:operand }}', 'input' => 5, 'operand' => 1
-    assert_template_result '2.3', "{{ '4.3' | minus:'2' }}"
+    assert_template_result "4", "{{ input | minus:operand }}", 'input' => 5, 'operand' => 1
+    assert_template_result "2.3", "{{ '4.3' | minus:'2' }}"
 
-    assert_template_result '5', "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7)
+    assert_template_result "5", "{{ price | minus:'2' }}", 'price' => NumberLikeThing.new(7)
   end
 
   def test_abs
-    assert_template_result '17', '{{ 17 | abs }}'
-    assert_template_result '17', '{{ -17 | abs }}'
-    assert_template_result '17', "{{ '17' | abs }}"
-    assert_template_result '17', "{{ '-17' | abs }}"
-    assert_template_result '0', '{{ 0 | abs }}'
-    assert_template_result '0', "{{ '0' | abs }}"
-    assert_template_result '17.42', '{{ 17.42 | abs }}'
-    assert_template_result '17.42', '{{ -17.42 | abs }}'
-    assert_template_result '17.42', "{{ '17.42' | abs }}"
-    assert_template_result '17.42', "{{ '-17.42' | abs }}"
+    assert_template_result "17", "{{ 17 | abs }}"
+    assert_template_result "17", "{{ -17 | abs }}"
+    assert_template_result "17", "{{ '17' | abs }}"
+    assert_template_result "17", "{{ '-17' | abs }}"
+    assert_template_result "0", "{{ 0 | abs }}"
+    assert_template_result "0", "{{ '0' | abs }}"
+    assert_template_result "17.42", "{{ 17.42 | abs }}"
+    assert_template_result "17.42", "{{ -17.42 | abs }}"
+    assert_template_result "17.42", "{{ '17.42' | abs }}"
+    assert_template_result "17.42", "{{ '-17.42' | abs }}"
   end
 
   def test_times
-    assert_template_result '12', '{{ 3 | times:4 }}'
-    assert_template_result '0', "{{ 'foo' | times:4 }}"
-    assert_template_result '6', "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
-    assert_template_result '7.25', '{{ 0.0725 | times:100 }}'
-    assert_template_result '-7.25', '{{ "-0.0725" | times:100 }}'
-    assert_template_result '7.25', '{{ "-0.0725" | times: -100 }}'
-    assert_template_result '4', '{{ price | times:2 }}', 'price' => NumberLikeThing.new(2)
+    assert_template_result "12", "{{ 3 | times:4 }}"
+    assert_template_result "0", "{{ 'foo' | times:4 }}"
+    assert_template_result "6", "{{ '2.1' | times:3 | replace: '.','-' | plus:0}}"
+    assert_template_result "7.25", "{{ 0.0725 | times:100 }}"
+    assert_template_result "-7.25", '{{ "-0.0725" | times:100 }}'
+    assert_template_result "7.25", '{{ "-0.0725" | times: -100 }}'
+    assert_template_result "4", "{{ price | times:2 }}", 'price' => NumberLikeThing.new(2)
   end
 
   def test_divided_by
-    assert_template_result '4', '{{ 12 | divided_by:3 }}'
-    assert_template_result '4', '{{ 14 | divided_by:3 }}'
+    assert_template_result "4", "{{ 12 | divided_by:3 }}"
+    assert_template_result "4", "{{ 14 | divided_by:3 }}"
 
-    assert_template_result '5', '{{ 15 | divided_by:3 }}'
-    assert_equal 'Liquid error: divided by 0', Template.parse('{{ 5 | divided_by:0 }}').render
+    assert_template_result "5", "{{ 15 | divided_by:3 }}"
+    assert_equal "Liquid error: divided by 0", Template.parse("{{ 5 | divided_by:0 }}").render
 
-    assert_template_result '0.5', '{{ 2.0 | divided_by:4 }}'
+    assert_template_result "0.5", "{{ 2.0 | divided_by:4 }}"
     assert_raises(Liquid::ZeroDivisionError) do
-      assert_template_result '4', '{{ 1 | modulo: 0 }}'
+      assert_template_result "4", "{{ 1 | modulo: 0 }}"
     end
 
-    assert_template_result '5', '{{ price | divided_by:2 }}', 'price' => NumberLikeThing.new(10)
+    assert_template_result "5", "{{ price | divided_by:2 }}", 'price' => NumberLikeThing.new(10)
   end
 
   def test_modulo
-    assert_template_result '1', '{{ 3 | modulo:2 }}'
+    assert_template_result "1", "{{ 3 | modulo:2 }}"
     assert_raises(Liquid::ZeroDivisionError) do
-      assert_template_result '4', '{{ 1 | modulo: 0 }}'
+      assert_template_result "4", "{{ 1 | modulo: 0 }}"
     end
 
-    assert_template_result '1', '{{ price | modulo:2 }}', 'price' => NumberLikeThing.new(3)
+    assert_template_result "1", "{{ price | modulo:2 }}", 'price' => NumberLikeThing.new(3)
   end
 
   def test_round
-    assert_template_result '5', '{{ input | round }}', 'input' => 4.6
-    assert_template_result '4', "{{ '4.3' | round }}"
-    assert_template_result '4.56', '{{ input | round: 2 }}', 'input' => 4.5612
+    assert_template_result "5", "{{ input | round }}", 'input' => 4.6
+    assert_template_result "4", "{{ '4.3' | round }}"
+    assert_template_result "4.56", "{{ input | round: 2 }}", 'input' => 4.5612
     assert_raises(Liquid::FloatDomainError) do
-      assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | round }}'
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | round }}"
     end
 
-    assert_template_result '5', '{{ price | round }}', 'price' => NumberLikeThing.new(4.6)
-    assert_template_result '4', '{{ price | round }}', 'price' => NumberLikeThing.new(4.3)
+    assert_template_result "5", "{{ price | round }}", 'price' => NumberLikeThing.new(4.6)
+    assert_template_result "4", "{{ price | round }}", 'price' => NumberLikeThing.new(4.3)
   end
 
   def test_ceil
-    assert_template_result '5', '{{ input | ceil }}', 'input' => 4.6
-    assert_template_result '5', "{{ '4.3' | ceil }}"
+    assert_template_result "5", "{{ input | ceil }}", 'input' => 4.6
+    assert_template_result "5", "{{ '4.3' | ceil }}"
     assert_raises(Liquid::FloatDomainError) do
-      assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | ceil }}'
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | ceil }}"
     end
 
-    assert_template_result '5', '{{ price | ceil }}', 'price' => NumberLikeThing.new(4.6)
+    assert_template_result "5", "{{ price | ceil }}", 'price' => NumberLikeThing.new(4.6)
   end
 
   def test_floor
-    assert_template_result '4', '{{ input | floor }}', 'input' => 4.6
-    assert_template_result '4', "{{ '4.3' | floor }}"
+    assert_template_result "4", "{{ input | floor }}", 'input' => 4.6
+    assert_template_result "4", "{{ '4.3' | floor }}"
     assert_raises(Liquid::FloatDomainError) do
-      assert_template_result '4', '{{ 1.0 | divided_by: 0.0 | floor }}'
+      assert_template_result "4", "{{ 1.0 | divided_by: 0.0 | floor }}"
     end
 
-    assert_template_result '5', '{{ price | floor }}', 'price' => NumberLikeThing.new(5.4)
+    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 | 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)
+    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", "{{ 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)
+    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)
-    assert_template_result('bcd', '{{ a | append: b}}', assigns)
+    assert_template_result('bcd', "{{ a | append: b}}", assigns)
   end
 
   def test_concat
@@ -663,7 +663,7 @@ class StandardFiltersTest < Minitest::Test
     assert_equal [1, 2, 'a'],  @filters.concat([1, 2], ['a'])
     assert_equal [1, 2, 10],   @filters.concat([1, 2], [10])
 
-    assert_raises(Liquid::ArgumentError, 'concat filter requires an array argument') do
+    assert_raises(Liquid::ArgumentError, "concat filter requires an array argument") do
       @filters.concat([1, 2], 10)
     end
   end
@@ -671,16 +671,16 @@ class StandardFiltersTest < Minitest::Test
   def test_prepend
     assigns = { 'a' => 'bc', 'b' => 'a' }
     assert_template_result('abc', "{{ a | prepend: 'a'}}", assigns)
-    assert_template_result('abc', '{{ a | prepend: b}}', assigns)
+    assert_template_result('abc', "{{ a | prepend: b}}", assigns)
   end
 
   def test_default
-    assert_equal 'foo', @filters.default('foo', 'bar')
-    assert_equal 'bar', @filters.default(nil, 'bar')
-    assert_equal 'bar', @filters.default('', 'bar')
-    assert_equal 'bar', @filters.default(false, 'bar')
-    assert_equal 'bar', @filters.default([], 'bar')
-    assert_equal 'bar', @filters.default({}, 'bar')
+    assert_equal "foo", @filters.default("foo", "bar")
+    assert_equal "bar", @filters.default(nil, "bar")
+    assert_equal "bar", @filters.default("", "bar")
+    assert_equal "bar", @filters.default(false, "bar")
+    assert_equal "bar", @filters.default([], "bar")
+    assert_equal "bar", @filters.default({}, "bar")
   end
 
   def test_cannot_access_private_methods
@@ -694,74 +694,74 @@ class StandardFiltersTest < Minitest::Test
 
   def test_where
     input = [
-      { 'handle' => 'alpha', 'ok' => true },
-      { 'handle' => 'beta', 'ok' => false },
-      { 'handle' => 'gamma', 'ok' => false },
-      { 'handle' => 'delta', 'ok' => true },
+      { "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 },
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "delta", "ok" => true },
     ]
 
-    assert_equal expectation, @filters.where(input, 'ok', true)
-    assert_equal expectation, @filters.where(input, 'ok')
+    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 },
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "beta" },
+      { "handle" => "gamma" },
+      { "handle" => "delta", "ok" => true },
     ]
 
     expectation = [
-      { 'handle' => 'alpha', 'ok' => true },
-      { 'handle' => 'delta', 'ok' => true },
+      { "handle" => "alpha", "ok" => true },
+      { "handle" => "delta", "ok" => true },
     ]
 
-    assert_equal expectation, @filters.where(input, 'ok', true)
-    assert_equal expectation, @filters.where(input, 'ok')
+    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')
+    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') }
+    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' },
+      { "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')
+    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')
+    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 },
+      { "foo" => false },
+      { "foo" => true },
+      { "foo" => "for sure" },
+      { "bar" => true },
     ]
 
-    assert_equal [{ 'foo' => true }, { 'foo' => 'for sure' }], @filters.where(input, 'foo')
+    assert_equal [{ "foo" => true }, { "foo" => "for sure" }], @filters.where(input, "foo")
   end
 
   private

test/integration/tags/break_tag_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class BreakTagTest < Minitest::Test

test/integration/tags/continue_tag_test.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'test_helper'
 
 class ContinueTagTest < Minitest::Test

test/integration/tags/echo_test.rb

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