Perf: Remove unneeded to_s and freeze strings

- No longer call to_s on string literals passed to undefined filters
- Freeze all string literals at the top of the generated code

This shows a ~9% performance improvement on the fluid benchmark when run without YJIT

.github/workflows/liquid.yml

@@ -0,0 +1,39 @@
+name: Liquid
+on: [push, pull_request]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        entry:
+          - { ruby: 2.5, allowed-failure: false } # minimum supported
+          - { ruby: 3.1, allowed-failure: false } # latest
+          - { ruby: ruby-head, allowed-failure: true }
+    name: test (${{ matrix.entry.ruby }})
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.entry.ruby }}
+      - uses: actions/cache@v1
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
+          restore-keys: ${{ runner.os }}-gems-
+      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
+      - run: bundle exec rake
+        continue-on-error: ${{ matrix.entry.allowed-failure }}
+  memory_profile:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: 2.7
+      - uses: actions/cache@v1
+        with:
+          path: vendor/bundle
+          key: ${{ runner.os }}-gems-${{ hashFiles('Gemfile') }}
+          restore-keys: ${{ runner.os }}-gems-
+      - run: bundle install --jobs=3 --retry=3 --path=vendor/bundle
+      - run: bundle exec rake memory_profile:run

.rubocop.yml

@@ -1,5 +1,7 @@
+inherit_gem:
+  rubocop-shopify: rubocop.yml
+
 inherit_from:
-  - 'https://shopify.github.io/ruby-style-guide/rubocop.yml'
   - .rubocop_todo.yml
 
 require: rubocop-performance
@@ -8,10 +10,15 @@ Performance:
   Enabled: true
 
 AllCops:
-  TargetRubyVersion: 2.4
+  TargetRubyVersion: 2.5
+  NewCops: disable
   Exclude:
     - 'vendor/bundle/**/*'
 
 Naming/MethodName:
   Exclude:
     - 'example/server/liquid_servlet.rb'
+
+# Backport https://github.com/Shopify/ruby-style-guide/pull/258
+Layout/BeginEndAlignment:
+  Enabled: true

.rubocop_todo.yml

@@ -1,6 +1,6 @@
 # This configuration was generated by
 # `rubocop --auto-gen-config`
-# on 2019-09-11 06:34:25 +1000 using RuboCop version 0.74.0.
+# on 2020-12-11 18:53:41 UTC using RuboCop version 1.6.1.
 # 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
@@ -14,14 +14,26 @@ Lint/InheritException:
   Exclude:
     - 'lib/liquid/interrupts.rb'
 
-# Offense count: 98
+# Offense count: 113
 # Cop supports --auto-correct.
 # Configuration parameters: AutoCorrect, AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
 # URISchemes: http, https
-Metrics/LineLength:
-  Max: 294
+Layout/LineLength:
+  Max: 260
 
-# Offense count: 44
+# Offense count: 8
+Lint/MissingSuper:
+  Exclude:
+    - 'lib/liquid/forloop_drop.rb'
+    - 'lib/liquid/tablerowloop_drop.rb'
+    - 'test/integration/assign_test.rb'
+    - 'test/integration/context_test.rb'
+    - 'test/integration/filter_test.rb'
+    - 'test/integration/standard_filter_test.rb'
+    - 'test/integration/tags/for_tag_test.rb'
+    - 'test/integration/tags/table_row_test.rb'
+
+# Offense count: 43
 Naming/ConstantName:
   Exclude:
     - 'lib/liquid.rb'
@@ -32,7 +44,6 @@ Naming/ConstantName:
     - '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'
@@ -40,9 +51,7 @@ Naming/ConstantName:
     - 'performance/shopify/paginate.rb'
     - 'test/integration/tags/include_tag_test.rb'
 
-# Offense count: 5
+# Offense count: 2
 Style/ClassVars:
   Exclude:
     - 'lib/liquid/condition.rb'
-    - 'lib/liquid/strainer.rb'
-    - 'lib/liquid/template.rb'

.travis.yml

@@ -1,26 +0,0 @@
-language: ruby
-cache: bundler
-
-rvm:
-  - 2.4
-  - 2.5
-  - &latest_ruby 2.6
-  - 2.7
-  - ruby-head
-
-matrix:
-  include:
-    - rvm: *latest_ruby
-      script: bundle exec rake memory_profile:run
-      name: Profiling Memory Usage
-  allow_failures:
-    - rvm: ruby-head
-
-branches:
-  only:
-    - master
-    - gh-pages
-    - /.*-stable/
-
-notifications:
-  disable: true

CONTRIBUTING.md

@@ -5,6 +5,7 @@
 * Bugfixes
 * Performance improvements
 * Features that are likely to be useful to the majority of Liquid users
+* Documentation updates that are concise and likely to be useful to the majority of Liquid users
 
 ## Things we won't merge
 
@@ -14,12 +15,14 @@
 * Features that can easily be implemented on top of Liquid (for example as a custom filter or custom filesystem)
 * Code that does not include tests
 * Code that breaks existing tests
+* Documentation changes that are verbose, incorrect or not important to most people (we want to keep it simple and easy to understand)
 
 ## Workflow
 
+* [Sign the CLA](https://cla.shopify.com/) if you haven't already
 * Fork the Liquid repository
 * Create a new branch in your fork
+  * For updating [Liquid documentation](https://shopify.github.io/liquid/), create it from `gh-pages` branch. (You can skip tests.)
 * If it makes sense, add tests for your code and/or run a performance benchmark
 * Make sure all tests pass (`bundle exec rake`)
 * Create a pull request
-

Gemfile

@@ -11,14 +11,20 @@ group :benchmark, :test do
   gem 'benchmark-ips'
   gem 'memory_profiler'
   gem 'terminal-table'
+  gem 'unicode_plot'
 
   install_if -> { RUBY_PLATFORM !~ /mingw|mswin|java/ && RUBY_ENGINE != 'truffleruby' } do
     gem 'stackprof'
   end
 end
 
+group :development do
+  gem 'pry-byebug'
+end
+
 group :test do
-  gem 'rubocop', '~> 0.74.0', require: false
+  gem 'rubocop', '~> 1.4', require: false
+  gem 'rubocop-shopify', '~> 1.0.7', require: false
   gem 'rubocop-performance', require: false
 
   platform :mri, :truffleruby do

History.md

@@ -1,5 +1,78 @@
 # Liquid Change Log
 
+## 5.3.0 2022-03-22
+
+### Fixes
+* StandardFilter: Fix missing @context on iterations (#1525) [Thierry Joyal]
+* Fix warning about block and default value in `static_registers.rb` (#1531) [Peter Zhu]
+
+### Deprecation
+* Condition#evaluate to require mandatory context argument in Liquid 6.0.0 (#1527) [Thierry Joyal]
+
+## 5.2.0 2022-03-01
+
+### Features
+* Add `remove_last`, and `replace_last` filters (#1422) [Anders Hagbard]
+* Eagerly cache global filters (#1524) [Jean Boussier]
+
+### Fixes
+* Fix some internal errors in filters from invalid input (#1476) [Dylan Thacker-Smith]
+* Allow dash in filter kwarg name for consistency with Liquid::C (#1518) [CP Clermont]
+
+## 5.1.0 / 2021-09-09
+
+### Features
+* Add `base64_encode`, `base64_decode`, `base64_url_safe_encode`, and `base64_url_safe_decode` filters (#1450) [Daniel Insley]
+* Introduce `to_liquid_value` in `Liquid::Drop` (#1441) [Michael Go]
+
+### Fixes
+* Fix support for using a String subclass for the liquid source (#1421) [Dylan Thacker-Smith]
+* Add `ParseTreeVisitor` to `RangeLookup` (#1470) [CP Clermont]
+* Translate `RangeError` to `Liquid::Error` for `truncatewords` with large int (#1431) [Dylan Thacker-Smith]
+
+## 5.0.1 / 2021-03-24
+
+### Fixes
+* Add ParseTreeVisitor to Echo tag (#1414) [CP Clermont]
+* Test with ruby 3.0 as the latest ruby version (#1398) [Dylan Thacker-Smith]
+* Handle carriage return in newlines_to_br (#1391) [Unending]
+
+### Performance Improvements
+* Use split limit in truncatewords (#1361) [Dylan Thacker-Smith]
+
+## 5.0.0 / 2021-01-06
+
+### Features
+* Add new `{% render %}` tag (#1122) [Samuel Doiron]
+* Add support for `as` in `{% render %}` and `{% include %}` (#1181) [Mike Angell]
+* Add `{% liquid %}` and `{% echo %}` tags (#1086) [Justin Li]
+* Add [usage tracking](README.md#usage-tracking) [Mike Angell]
+* Add `Tag.disable_tags` for disabling tags that prepend `Tag::Disableable` at render time (#1162, #1274, #1275) [Mike Angell]
+* Support using a profiler for multiple renders (#1365, #1366) [Dylan Thacker-Smith]
+
+### Fixes
+* Fix catastrophic backtracking in `RANGES_REGEX` regular expression (#1357) [Dylan Thacker-Smith]
+* Make sure the for tag's limit and offset are integers (#1094) [David Cornu]
+* Invokable methods for enumerable reject include (#1151) [Thierry Joyal]
+* Allow `default` filter to handle `false` as value (#1144) [Mike Angell]
+* Fix render length resource limit so it doesn't multiply nested output (#1285) [Dylan Thacker-Smith]
+* Fix duplication of text in raw tags (#1304) [Peter Zhu]
+* Fix strict parsing of find variable with a name expression (#1317) [Dylan Thacker-Smith]
+* Use monotonic time to measure durations in Liquid::Profiler (#1362) [Dylan Thacker-Smith]
+
+### Breaking Changes
+* Require Ruby >= 2.5 (#1131, #1310) [Mike Angell, Dylan Thacker-Smith]
+* Remove support for taint checking (#1268) [Dylan Thacker-Smith]
+* Split Strainer class into StrainerFactory and StrainerTemplate (#1208) [Thierry Joyal]
+* Remove handling of a nil context in the Strainer class (#1218) [Thierry Joyal]
+* Handle `BlockBody#blank?` at parse time (#1287) [Dylan Thacker-Smith]
+* Pass the tag markup and tokenizer to `Document#unknown_tag` (#1290) [Dylan Thacker-Smith]
+* And several internal changes
+
+### Performance Improvements
+* Reduce allocations (#1073, #1091, #1115, #1099, #1117, #1141, #1322, #1341) [Richard Monette, Florian Weingarten, Ashwin Maroli]
+* Improve resources limits performance (#1093, #1323) [Florian Weingarten, Dylan Thacker-Smith]
+
 ## 4.0.3 / 2019-03-12
 
 ### Fixed

README.md

@@ -5,7 +5,7 @@
 
 * [Contributing guidelines](CONTRIBUTING.md)
 * [Version history](History.md)
-* [Liquid documentation from Shopify](http://docs.shopify.com/themes/liquid-basics)
+* [Liquid documentation from Shopify](https://shopify.dev/api/liquid)
 * [Liquid Wiki at GitHub](https://github.com/Shopify/liquid/wiki)
 * [Website](http://liquidmarkup.org/)
 
@@ -56,7 +56,7 @@ For standard use you can just pass it the content of a file and call render with
 
 Setting the error mode of Liquid lets you specify how strictly you want your templates to be interpreted.
 Normally the parser is very lax and will accept almost anything without error. Unfortunately this can make
-it very hard to debug and can lead to unexpected behaviour. 
+it very hard to debug and can lead to unexpected behaviour.
 
 Liquid also comes with a stricter parser that can be used when editing templates to give better error messages
 when templates are invalid. You can enable this new parser like this:

Rakefile

@@ -9,9 +9,15 @@ task(default: [:test, :rubocop])
 
 desc('run test suite with default parser')
 Rake::TestTask.new(:base_test) do |t|
-  t.libs << '.' << 'lib' << 'test'
+  t.libs << 'lib' << 'test'
   t.test_files = FileList['test/{integration,unit}/**/*_test.rb']
-  t.verbose = false
+  t.verbose    = false
+end
+
+Rake::TestTask.new(:integration_test) do |t|
+  t.libs << 'lib' << 'test'
+  t.test_files = FileList['test/integration/**/*_test.rb']
+  t.verbose    = false
 end
 
 desc('run test suite with warn error mode')
@@ -40,13 +46,28 @@ task :test do
     ENV['LIQUID_C'] = '1'
 
     ENV['LIQUID_PARSER_MODE'] = 'lax'
-    Rake::Task['base_test'].reenable
-    Rake::Task['base_test'].invoke
+    Rake::Task['integration_test'].reenable
+    Rake::Task['integration_test'].invoke
 
     ENV['LIQUID_PARSER_MODE'] = 'strict'
-    Rake::Task['base_test'].reenable
-    Rake::Task['base_test'].invoke
+    Rake::Task['integration_test'].reenable
+    Rake::Task['integration_test'].invoke
   end
+
+  if RUBY_ENGINE == 'ruby'
+    Rake::Task['test_compile'].invoke
+  end
+end
+
+task :test_compile do
+  ENV['LIQUID_COMPILE'] = '1'
+  ENV['LIQUID_PARSER_MODE'] = 'lax'
+  Rake::Task['integration_test'].reenable
+  Rake::Task['integration_test'].invoke
+
+  ENV['LIQUID_PARSER_MODE'] = 'strict'
+  Rake::Task['integration_test'].reenable
+  Rake::Task['integration_test'].invoke
 end
 
 task(gem: :build)
@@ -71,6 +92,22 @@ namespace :benchmark do
     ruby "./performance/benchmark.rb lax"
   end
 
+  desc "Compare the render performance of compiled Liquid to standard Liquid and Liquid-C"
+  task :compare_render do
+    ENV.delete("LIQUID_C")
+    ENV.delete("RENDER_ONLY")
+
+    ENV["LIQUID_COMPILE"] = "1"
+    ruby "./performance/benchmark.rb strict"
+
+    ENV.delete("LIQUID_COMPILE")
+    ruby "./performance/benchmark.rb strict"
+
+    ENV["LIQUID_C"] = "1"
+    ruby "./performance/benchmark.rb strict"
+
+  end
+
   desc "Run the liquid benchmark with strict parsing"
   task :strict do
     ruby "./performance/benchmark.rb strict"

example/server/liquid_servlet.rb

@@ -12,16 +12,16 @@ class LiquidServlet < WEBrick::HTTPServlet::AbstractServlet
   private
 
   def handle(_type, req, res)
-    @request = req
+    @request  = req
     @response = res
 
     @request.path_info =~ /(\w+)\z/
-    @action = Regexp.last_match(1) || 'index'
+    @action  = Regexp.last_match(1) || 'index'
     @assigns = send(@action) if respond_to?(@action)
 
     @response['Content-Type'] = "text/html"
     @response.status = 200
-    @response.body = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
+    @response.body   = Liquid::Template.parse(read_template).render(@assigns, filters: [ProductsFilter])
   end
 
   def read_template(filename = @action)

fluid-bench/benchmark.rb

@@ -0,0 +1,26 @@
+# https://github.com/evanphx/benchmark-ips
+require 'liquid'
+#require 'liquid/c'
+require 'benchmark/ips'
+
+require_relative '../lib/liquid/compile'
+
+require_relative 'shop_filter'
+require_relative 'money_filter'
+
+# Each database table is a hash
+require_relative 'database'
+tables = Database.tables
+
+Liquid::Template.register_filter(MoneyFilter)
+Liquid::Template.register_filter(ShopFilter)
+@template = Liquid::Template.parse(File.read("product.liquid"))
+
+context = Liquid::Context.new([tables, {}], {}, {}, false, Liquid::ResourceLimits.new(Liquid::Template.default_resource_limits))
+
+Benchmark.ips do |x|
+    x.report("render") { @template.render(context) }
+
+    # Compare the iterations per second of the various reports
+    x.compare!
+end

fluid-bench/database.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'stackprof'
+
+module Database
+  DATABASE_FILE_PATH = "#{__dir__}/vision.database.yml"
+
+  # Load the standard vision toolkit database and re-arrage it to be simply exportable
+  # to liquid as assigns. All this is based on Shopify
+  def self.tables
+    @tables ||= begin
+      db =
+        if YAML.respond_to?(:unsafe_load_file) # Only Psych 4+ can use unsafe_load_file
+          # unsafe_load_file is needed for YAML references
+          YAML.unsafe_load_file(DATABASE_FILE_PATH, symbolize_names: true)
+        else
+          YAML.load_file(DATABASE_FILE_PATH, symbolize_names: true)
+        end
+
+      # From vision source
+      db[:products].each do |product|
+        collections = db[:collections].find_all do |collection|
+          collection[:products].any? { |p| p[:id].to_i == product[:id].to_i }
+        end
+        product[:collections] = collections
+      end
+
+      # key the tables by handles, as this is how liquid expects it.
+      db = db.each_with_object({}) do |(key, values), assigns|
+        assigns[key] = values.each_with_object({}) do |v, h|
+          h[v[:handle]] = v
+        end
+      end
+
+      # Some standard direct accessors so that the specialized templates
+      # render correctly
+      db[:collection] = db[:collections].values.first
+      db[:product]    = db[:products].values.first
+      db[:blog]       = db[:blogs].values.first
+      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] },
+        :items => db[:line_items].values,
+      }
+
+      db
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  p(Database.tables[:collections][:frontpage].keys)
+  # p Database.tables[:blog][:articles]
+end

fluid-bench/money_filter.rb

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

fluid-bench/product.liquid

@@ -0,0 +1,36 @@
+<div id="product-left">
+  {% for image in product.images %}{% if forloop.first %}<div id="product-image">
+    <a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'medium' }}" alt="{{ product.title | escape }}" /></a>
+  </div>{% else %}
+  <div class="product-images">
+    <a href="{{ image | product_img_url: 'large' }}" rel="lightbox[images]" title="{{ product.title | escape }}"><img src="{{ image | product_img_url: 'small' }}" alt="{{ product.title | escape }}" /></a>
+  </div>{% endif %}{% endfor %}
+</div>
+<div id="product-right">
+  <h1>{{ product.title }}</h1>
+  {{ product.description }}
+
+  {% if product.available %}
+  <form action="/cart/add" method="post">
+
+    <div id="product-variants">
+      <div id="price-field"></div>
+
+      <select id="product-select" name='id'>
+        {% for variant in product.variants %}
+          <option value="{{ variant.id }}">{{ variant.title }} - {{ variant.price | money }}</option>
+        {% endfor %}
+      </select>
+    </div>
+
+    <input type="image" src="{{ 'purchase.png' | asset_url }}" name="add" value="Purchase" id="purchase" />
+  </form>
+  {% else %}
+    <p class="bold-red">This product is temporarily unavailable</p>
+  {% endif %}
+
+  <div id="product-details">
+    <strong>Continue Shopping</strong><br />
+    Browse more {{ product.type | link_to_type }} or additional {{ product.vendor | link_to_vendor }} products.
+  </div>
+</div>

fluid-bench/shop_filter.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module ShopFilter
+  def asset_url(input)
+    "/files/1/[shop_id]/[shop_id]/assets/#{input}"
+  end
+
+  def global_asset_url(input)
+    "/global/#{input}"
+  end
+
+  def shopify_asset_url(input)
+    "/shopify/#{input}"
+  end
+
+  def script_tag(url)
+    %(<script src="#{url}" type="text/javascript"></script>)
+  end
+
+  def stylesheet_tag(url, media = "all")
+    %(<link href="#{url}" rel="stylesheet" type="text/css"  media="#{media}"  />)
+  end
+
+  def link_to(link, url, title = "")
+    %(<a href="#{url}" title="#{title}">#{link}</a>)
+  end
+
+  def img_tag(url, alt = "")
+    %(<img src="#{url}" alt="#{alt}" />)
+  end
+
+  def link_to_vendor(vendor)
+    if vendor
+      link_to(vendor, url_for_vendor(vendor), vendor)
+    else
+      'Unknown Vendor'
+    end
+  end
+
+  def link_to_type(type)
+    if type
+      link_to(type, url_for_type(type), type)
+    else
+      'Unknown Vendor'
+    end
+  end
+
+  def url_for_vendor(vendor_title)
+    "/collections/#{to_handle(vendor_title)}"
+  end
+
+  def url_for_type(type_title)
+    "/collections/#{to_handle(type_title)}"
+  end
+
+  def product_img_url(url, style = 'small')
+    unless url =~ %r{\Aproducts/([\w\-\_]+)\.(\w{2,4})}
+      raise ArgumentError, 'filter "size" can only be called on product images'
+    end
+
+    case style
+    when 'original'
+      '/files/shops/random_number/' + url
+    when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
+      "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
+    else
+      raise ArgumentError, 'valid parameters for filter "size" are: original, grande, large, medium, compact, small, thumb and icon '
+    end
+  end
+
+  def default_pagination(paginate)
+    html = []
+    html << %(<span class="prev">#{link_to(paginate['previous']['title'], paginate['previous']['url'])}</span>) if paginate['previous']
+
+    paginate['parts'].each do |part|
+      html << if part['is_link']
+        %(<span class="page">#{link_to(part['title'], part['url'])}</span>)
+      elsif part['title'].to_i == paginate['current_page'].to_i
+        %(<span class="page current">#{part['title']}</span>)
+      else
+        %(<span class="deco">#{part['title']}</span>)
+      end
+    end
+
+    html << %(<span class="next">#{link_to(paginate['next']['title'], paginate['next']['url'])}</span>) if paginate['next']
+    html.join(' ')
+  end
+
+  # Accepts a number, and two words - one for singular, one for plural
+  # Returns the singular word if input equals 1, otherwise plural
+  def pluralize(input, singular, plural)
+    input == 1 ? singular : plural
+  end
+
+  private
+
+  def to_handle(str)
+    result = str.dup
+    result.downcase!
+    result.delete!("'\"()[]")
+    result.gsub!(/\W+/, '-')
+    result.gsub!(/-+\z/, '') if result[-1] == '-'
+    result.gsub!(/\A-+/, '') if result[0] == '-'
+    result
+  end
+end

fluid-bench/vision.database.yml

@@ -0,0 +1,945 @@
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Variants
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+product_variants:
+  - &product-1-var-1
+    id: 1
+    title: 151cm / Normal
+    price: 19900
+    weight: 1000
+    compare_at_price: 49900
+    available: true
+    inventory_quantity: 5
+    option1: 151cm
+    option2: Normal
+    option3:
+  - &product-1-var-2
+    id: 2
+    title: 155cm / Normal
+    price: 31900
+    weight: 1000
+    compare_at_price: 50900
+    available: true
+    inventory_quantity: 2
+    option1: 155cm
+    option2: Normal
+    option3:
+  - &product-2-var-1
+    id: 3
+    title: 162cm
+    price: 29900
+    weight: 1000
+    compare_at_price: 52900
+    available: true
+    inventory_quantity: 3
+    option1: 162cm
+    option2:
+    option3:
+  - &product-3-var-1
+    id: 4
+    title: 159cm
+    price: 19900
+    weight: 1000
+    compare_at_price:
+    available: true
+    inventory_quantity: 4
+    option1: 159cm
+    option2:
+    option3:
+  - &product-4-var-1
+    id: 5
+    title: 159cm
+    price: 19900
+    weight: 1000
+    compare_at_price: 32900
+    available: true
+    inventory_quantity: 6
+    option1: 159cm
+    option2:
+    option3:
+  - &product-1-var-3
+    id: 6
+    title: 158cm / Wide
+    price: 23900
+    weight: 1000
+    compare_at_price: 99900
+    available: false
+    inventory_quantity: 0
+    option1: 158cm
+    option2: Wide
+    option3:
+  - &product-3-var-2
+    id: 7
+    title: 162cm
+    price: 19900
+    weight: 1000
+    compare_at_price:
+    available: false
+    inventory_quantity: 0
+    option1: 162cm
+    option2:
+    option3:
+  - &product-3-var-3
+    id: 8
+    title: 165cm
+    price: 22900
+    weight: 1000
+    compare_at_price:
+    available: true
+    inventory_quantity: 4
+    option1: 165cm
+    option2:
+    option3:
+  - &product-5-var-1
+    id: 9
+    title: black / 42
+    price: 11900
+    weight: 500
+    compare_at_price: 22900
+    available: true
+    inventory_quantity: 1
+    option1: black
+    option2: 42
+    option3:
+  - &product-5-var-2
+    id: 10
+    title: beige / 42
+    price: 11900
+    weight: 500
+    compare_at_price: 22900
+    available: true
+    inventory_quantity: 3
+    option1: beige
+    option2: 42
+    option3:
+  - &product-5-var-3
+    id: 11
+    title: white / 42
+    price: 13900
+    weight: 500
+    compare_at_price: 24900
+    available: true
+    inventory_quantity: 1
+    option1: white
+    option2: 42
+    option3:
+  - &product-5-var-4
+    id: 12
+    title: black / 44
+    price: 11900
+    weight: 500
+    compare_at_price: 22900
+    available: true
+    inventory_quantity: 2
+    option1: black
+    option2: 44
+    option3:
+  - &product-5-var-5
+    id: 13
+    title: beige / 44
+    price: 11900
+    weight: 500
+    compare_at_price: 22900
+    available: false
+    inventory_quantity: 0
+    option1: beige
+    option2: 44
+    option3:
+  - &product-5-var-6
+    id: 14
+    title: white / 44
+    price: 13900
+    weight: 500
+    compare_at_price: 24900
+    available: false
+    inventory_quantity: 0
+    option1: white
+    option2: 44
+    option3:
+  - &product-6-var-1
+    id: 15
+    title: red
+    price: 2179500
+    weight: 200000
+    compare_at_price:
+    available: true
+    inventory_quantity: 0
+    option1: red
+    option2:
+    option3:
+  - &product-7-var-1
+    id: 16
+    title: black / small
+    price: 1900
+    weight: 200
+    compare_at_price:
+    available: true
+    inventory_quantity: 20
+    option1: black
+    option2: small
+    option3:
+  - &product-7-var-2
+    id: 17
+    title: black / medium
+    price: 1900
+    weight: 200
+    compare_at_price:
+    available: false
+    inventory_quantity: 0
+    option1: black
+    option2: medium
+    option3:
+  - &product-7-var-3
+    id: 18
+    title: black / large
+    price: 1900
+    weight: 200
+    compare_at_price:
+    available: true
+    inventory_quantity: 10
+    option1: black
+    option2: large
+    option3:
+  - &product-7-var-4
+    id: 19
+    title: black / extra large
+    price: 1900
+    weight: 200
+    compare_at_price:
+    available: false
+    inventory_quantity: 0
+    option1: black
+    option2: extra large
+    option3:
+  - &product-8-var-1
+    id: 20
+    title: brown / small
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: true
+    inventory_quantity: 5
+    option1: brown
+    option2: small
+    option3:
+  - &product-8-var-2
+    id: 21
+    title: brown / medium
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: false
+    inventory_quantity: 0
+    option1: brown
+    option2: medium
+    option3:
+  - &product-8-var-3
+    id: 22
+    title: brown / large
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: true
+    inventory_quantity: 10
+    option1: brown
+    option2: large
+    option3:
+  - &product-8-var-4
+    id: 23
+    title: black / small
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: true
+    inventory_quantity: 10
+    option1: black
+    option2: small
+    option3:
+  - &product-8-var-5
+    id: 24
+    title: black / medium
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: true
+    inventory_quantity: 10
+    option1: black
+    option2: medium
+    option3:
+  - &product-8-var-6
+    id: 25
+    title: black / large
+    price: 5900
+    weight: 400
+    compare_at_price: 6900
+    available: false
+    inventory_quantity: 0
+    option1: black
+    option2: large
+    option3:
+  - &product-9-var-1
+    id: 26
+    title: Body Only
+    price: 499995
+    weight: 2000
+    compare_at_price:
+    available: true
+    inventory_quantity: 3
+    option1: Body Only
+    option2:
+    option3:
+  - &product-9-var-2
+    id: 27
+    title: Kit with 18-55mm VR lens
+    price: 523995
+    weight: 2000
+    compare_at_price:
+    available: true
+    inventory_quantity: 2
+    option1: Kit with 18-55mm VR lens
+    option2:
+    option3:
+  - &product-9-var-3
+    id: 28
+    title: Kit with 18-200 VR lens
+    price: 552500
+    weight: 2000
+    compare_at_price:
+    available: true
+    inventory_quantity: 3
+    option1: Kit with 18-200 VR lens
+    option2:
+    option3:
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Products
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+products:
+  - &product-1
+    id: 1
+    title: Arbor Draft
+    handle: arbor-draft
+    type: Snowboards
+    vendor: Arbor
+    price: 23900
+    price_max: 31900
+    price_min: 23900
+    price_varies: true
+    available: true
+    tags:
+      - season2005
+      - pro
+      - intermediate
+      - wooden
+      - freestyle
+    options:
+      - Length
+      - Style
+    compare_at_price: 49900
+    compare_at_price_max: 50900
+    compare_at_price_min: 49900
+    compare_at_price_varies: true
+    url: /products/arbor-draft
+    featured_image: products/arbor_draft.jpg
+    images:
+      - products/arbor_draft.jpg
+    description:
+      The Arbor Draft snowboard wouldn't exist if Polynesians hadn't figured out how to surf hundreds of years ago. But the Draft does exist, and it's here to bring your urban and park riding to a new level. The board's freaky Tiki design pays homage to culture that inspired snowboarding. It's designed to spin with ease, land smoothly, lock hook-free onto rails, and take the abuse of a pavement pounding or twelve. The Draft will pop off kickers with authority and carve solidly across the pipe. The Draft features targeted Koa wood die cuts inlayed into the deck that enhance the flex pattern. Now bow down to riding's ancestors.
+    variants:
+      - *product-1-var-1
+      - *product-1-var-2
+      - *product-1-var-3
+  - &product-2
+    id: 2
+    title: Arbor Element
+    handle: arbor-element
+    type: Snowboards
+    vendor: Arbor
+    price: 29900
+    price_max: 29900
+    price_min: 29900
+    price_varies: false
+    available: true
+    tags:
+      - season2005
+      - pro
+      - wooden
+      - freestyle
+    options:
+      - Length
+    compare_at_price: 52900
+    compare_at_price_max: 52900
+    compare_at_price_min: 52900
+    compare_at_price_varies: false
+    url: /products/arbor-element
+    featured_image: products/element58.jpg
+    images:
+      - products/element58.jpg
+    description:
+      The Element is a technically advanced all-mountain board for riders who readily transition from one terrain, snow condition, or riding style to another. Its balanced design provides the versatility needed for the true ride-it-all experience. The Element is exceedingly lively, freely initiates, and holds a tight edge at speed. Its structural real-wood topsheet is made with book-matched Koa.
+    variants:
+      - *product-2-var-1
+
+  - &product-3
+    id: 3
+    title: Comic ~ Pastel
+    handle: comic-pastel
+    type: Snowboards
+    vendor: Technine
+    price: 19900
+    price_max: 22900
+    price_min: 19900
+    tags:
+      - season2006
+      - beginner
+      - intermediate
+      - freestyle
+      - purple
+    options:
+      - Length
+    price_varies: true
+    available: true
+    compare_at_price:
+    compare_at_price_max: 0
+    compare_at_price_min: 0
+    compare_at_price_varies: false
+    url: /products/comic-pastel
+    featured_image: products/technine1.jpg
+    images:
+      - products/technine1.jpg
+      - products/technine2.jpg
+      - products/technine_detail.jpg
+    description:
+      2005 Technine Comic Series Description The Comic series was developed to be the ultimate progressive freestyle board in the Technine line. Dependable edge control and a perfect flex pattern for jumping in the park or out of bounds. Landins and progression will come easy with this board and it will help your riding progress to the next level. Street rails, park jibs, backcountry booters and park jumps, this board will do it all.
+    variants:
+      - *product-3-var-1
+      - *product-3-var-2
+      - *product-3-var-3
+
+  - &product-4
+    id: 4
+    title: Comic ~ Orange
+    handle: comic-orange
+    type: Snowboards
+    vendor: Technine
+    price: 19900
+    price_max: 19900
+    price_min: 19900
+    price_varies: false
+    available: true
+    tags:
+      - season2006
+      - beginner
+      - intermediate
+      - freestyle
+      - orange
+    options:
+      - Length
+    compare_at_price: 32900
+    compare_at_price_max: 32900
+    compare_at_price_min: 32900
+    compare_at_price_varies: false
+    url: /products/comic-orange
+    featured_image: products/technine3.jpg
+    images:
+      - products/technine3.jpg
+      - products/technine4.jpg
+    description:
+      2005 Technine Comic Series Description The Comic series was developed to be the ultimate progressive freestyle board in the Technine line. Dependable edge control and a perfect flex pattern for jumping in the park or out of bounds. Landins and progression will come easy with this board and it will help your riding progress to the next level. Street rails, park jibs, backcountry booters and park jumps, this board will do it all.
+    variants:
+      - *product-4-var-1
+
+  - &product-5
+    id: 5
+    title: Burton Boots
+    handle: burton-boots
+    type: Boots
+    vendor: Burton
+    price: 11900
+    price_max: 11900
+    price_min: 11900
+    price_varies: false
+    available: true
+    tags:
+      - season2006
+      - beginner
+      - intermediate
+      - boots
+    options:
+      - Color
+      - Shoe Size
+    compare_at_price: 22900
+    compare_at_price_max: 22900
+    compare_at_price_min: 22900
+    compare_at_price_varies: false
+    url: /products/burton-boots
+    featured_image: products/burton.jpg
+    images:
+      - products/burton.jpg
+    description:
+      The Burton boots are particularly well on snowboards. The very best thing about them is that the according picture is cubic. This makes testing in a Vision testing environment very easy.
+    variants:
+      - *product-5-var-1
+      - *product-5-var-2
+      - *product-5-var-3
+      - *product-5-var-4
+      - *product-5-var-5
+      - *product-5-var-6
+
+  - &product-6
+    id: 6
+    title: Superbike 1198 S
+    handle: superbike
+    type: Superbike
+    vendor: Ducati
+    price: 2179500
+    price_max: 2179500
+    price_min: 2179500
+    price_varies: false
+    available: true
+    tags:
+      - ducati
+      - superbike
+      - bike
+      - street
+      - racing
+      - performance
+    options:
+      - Color
+    compare_at_price:
+    compare_at_price_max: 0
+    compare_at_price_min: 0
+    compare_at_price_varies: false
+    url: /products/superbike
+    featured_image: products/ducati.jpg
+    images:
+      - products/ducati.jpg
+    description:
+      <h3>‘S’ PERFORMANCE</h3>
+      <p>Producing 170hp (125kW) and with a dry weight of just 169kg (372.6lb), the new 1198 S now incorporates more World Superbike technology than ever before by taking the 1198 motor and adding top-of-the-range suspension, lightweight chassis components and a true racing-style traction control system designed for road use.</p>
+      <p>The high performance, fully adjustable 43mm Öhlins forks, which sport low friction titanium nitride-treated fork sliders, respond effortlessly to every imperfection in the tarmac. Beyond their advanced engineering solutions, one of the most important characteristics of Öhlins forks is their ability to communicate the condition and quality of the tyre-to-road contact patch, a feature that puts every rider in superior control. The suspension set-up at the rear is complemented with a fully adjustable Öhlins rear shock equipped with a ride enhancing top-out spring and mounted to a single-sided swingarm for outstanding drive and traction. The front-to-rear Öhlins package is completed with a control-enhancing adjustable steering damper.</p>
+    variants:
+      - *product-6-var-1
+
+  - &product-7
+    id: 7
+    title: Shopify Shirt
+    handle: shopify-shirt
+    type: Shirt
+    vendor: Shopify
+    price: 1900
+    price_max: 1900
+    price_min: 1900
+    price_varies: false
+    available: true
+    tags:
+      - shopify
+      - shirt
+      - apparel
+      - tshirt
+      - clothing
+    options:
+      - Color
+      - Size
+    compare_at_price:
+    compare_at_price_max: 0
+    compare_at_price_min: 0
+    compare_at_price_varies: false
+    url: /products/shopify-shirt
+    featured_image: products/shopify_shirt.png
+    images:
+      - products/shopify_shirt.png
+    description:
+      <p>High Quality Shopify Shirt. Wear your e-commerce solution with pride and attract attention anywhere you go.</p>
+      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
+    variants:
+      - *product-7-var-1
+      - *product-7-var-2
+      - *product-7-var-3
+      - *product-7-var-4
+
+  - &product-8
+    id: 8
+    title: Hooded Sweater
+    handle: hooded-sweater
+    type: Sweater
+    vendor: Stormtech
+    price: 5900
+    price_max: 5900
+    price_min: 5900
+    price_varies: false
+    available: true
+    tags:
+      - sweater
+      - hooded
+      - apparel
+      - clothing
+    options:
+      - Color
+      - Size
+    compare_at_price: 6900
+    compare_at_price_max: 6900
+    compare_at_price_min: 6900
+    compare_at_price_varies: false
+    url: /products/hooded-sweater
+    featured_image: products/hooded-sweater.jpg
+    images:
+      - products/hooded-sweater.jpg
+      - products/hooded-sweater-b.jpg
+    description:
+      <p>Extra comfortable zip up sweater. Durable quality, ideal for any outdoor activities.</p>
+      <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
+    variants:
+      - *product-8-var-1
+      - *product-8-var-2
+      - *product-8-var-3
+      - *product-8-var-4
+      - *product-8-var-5
+      - *product-8-var-6
+
+  - &product-9
+    id: 9
+    title: D3 Digital SLR Camera
+    handle: d3
+    type: SLR
+    vendor: Nikon
+    price: 499995
+    price_max: 552500
+    price_min: 499995
+    price_varies: true
+    available: true
+    tags:
+      - camera
+      - slr
+      - nikon
+      - professional
+    options:
+      - Bundle
+    compare_at_price:
+    compare_at_price_max: 0
+    compare_at_price_min: 0
+    compare_at_price_varies: false
+    url: /products/d3
+    featured_image: products/d3.jpg
+    images:
+      - products/d3.jpg
+      - products/d3_2.jpg
+      - products/d3_3.jpg
+    description:
+      <p>Flagship pro D-SLR with a 12.1-MP FX-format CMOS sensor, blazing 9 fps shooting at full FX resolution and low-noise performance up to 6400 ISO.</p>
+      <p><strong>Nikon's original 12.1-megapixel FX-format (23.9 x 36mm) CMOS sensor:</strong> Couple Nikon's exclusive digital image processing system with the 12.1-megapixel FX-format and you'll get breathtakingly rich images while also reducing noise to unprecedented levels with even higher ISOs.</p>
+      <p><strong>Continuous shooting at up to 9 frames per second:</strong> At full FX resolution and up to 11fps in the DX crop mode, the D3 offers uncompromised shooting speeds for fast-action and sports photography.</p>
+    variants:
+      - *product-9-var-1
+      - *product-9-var-2
+      - *product-9-var-3
+
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Line Items
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+line_items:
+  - &line_item-1
+    id: 1
+    title: 'Arbor Draft'
+    subtitle: '151cm'
+    price: 29900
+    line_price: 29900
+    quantity: 1
+    variant: *product-1-var-1
+    product: *product-1
+
+  - &line_item-2
+    id: 2
+    title: 'Comic ~ Orange'
+    subtitle: '159cm'
+    price: 19900
+    line_price: 39800
+    quantity: 2
+    variant: *product-4-var-1
+    product: *product-4
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Link Lists
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+links:
+  - &link-1
+    id: 1
+    title: Our Sale
+    url: /collections/sale
+  - &link-2
+    id: 2
+    title: Arbor Stuff
+    url: /collections/arbor
+  - &link-3
+    id: 3
+    title: All our Snowboards
+    url: /collections/snowboards
+  - &link-4
+    id: 4
+    title: Powered by Shopify
+    url: 'http://shopify.com'
+  - &link-5
+    id: 5
+    title: About Us
+    url: /pages/about-us
+  - &link-6
+    id: 6
+    title: Policies
+    url: /pages/shipping
+  - &link-7
+    id: 7
+    title: Contact Us
+    url: /pages/contact
+  - &link-8
+    id: 8
+    title: Our blog
+    url: /blogs/bigcheese-blog
+  - &link-9
+    id: 9
+    title: New Boots
+    url: /products/burton-boots
+  - &link-10
+    id: 10
+    title: Paginated Sale
+    url: /collections/paginated-sale
+  - &link-11
+    id: 11
+    title: Our Paginated blog
+    url: /blogs/paginated-blog
+  - &link-12
+    id: 12
+    title: Catalog
+    url: /collections/all
+
+
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Link Lists
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+link_lists:
+  - &link-list-1
+    id: 1
+    title: 'Main Menu'
+    handle: 'main-menu'
+    links:
+      - *link-12
+      - *link-5
+      - *link-7
+      - *link-8
+  - &link-list-2
+    id: 1
+    title: 'Footer Menu'
+    handle: 'footer'
+    links:
+      - *link-5
+      - *link-6
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Collections
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+
+collections:
+  - &collection-1
+    id: 1
+    title: Frontpage
+    handle: frontpage
+    url: /collections/frontpage
+    products:
+      - *product-7
+      - *product-8
+      - *product-9
+
+  - &collection-2
+    id: 2
+    title: Arbor
+    handle: arbor
+    url: /collections/arbor
+    products:
+      - *product-1
+      - *product-2
+
+  - &collection-3
+    id: 3
+    title: Snowboards
+    handle: snowboards
+    url: /collections/snowboards
+    description:
+      <p>This is a description for my <strong>Snowboards</strong> collection.</p>
+    products:
+      - *product-1
+      - *product-2
+      - *product-3
+      - *product-4
+
+  - &collection-4
+    id: 4
+    title: Items On Sale
+    handle: sale
+    url: /collections/sale
+    products:
+      - *product-1
+
+  - &collection-5
+    id: 5
+    title: Paginated Sale
+    handle: 'paginated-sale'
+    url: '/collections/paginated-sale'
+    products:
+      - *product-1
+      - *product-2
+      - *product-3
+      - *product-4
+    products_count: 210
+
+  - &collection-6
+    id: 6
+    title: All products
+    handle: 'all'
+    url: '/collections/all'
+    products:
+      - *product-7
+      - *product-8
+      - *product-9
+      - *product-6
+      - *product-1
+      - *product-2
+      - *product-3
+      - *product-4
+      - *product-5
+
+
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+#   Pages and Blogs
+# =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
+pages:
+  - &page-2
+    id: 1
+    title: Contact Us
+    handle: contact
+    url: /pages/contact
+    author: Tobi
+    content:
+      "<p>You can contact us via phone under (555) 567-2222.</p>
+      <p>Our retail store is located at <em>Rue d'Avignon 32, Avignon (Provence)</em>.</p>
+      <p><strong>Opening Hours:</strong><br />Monday through Friday: 9am - 6pm<br />Saturday: 10am - 3pm<br />Sunday: closed</p>"
+    created_at: 2005-04-04 12:00
+
+  - &page-3
+    id: 2
+    title: About Us
+    handle: about-us
+    url: /pages/about-us
+    author: Tobi
+    content:
+      "<p>Our company was founded in 1894 and we are since operating out of Avignon from the beautiful Provence.</p>
+      <p>We offer the highest quality products and are proud to serve our customers to their heart's content.</p>"
+    created_at: 2005-04-04 12:00
+
+  - &page-4
+    id: 3
+    title: Shopping Cart
+    handle: shopping-cart
+    url: /pages/shopping-cart
+    author: Tobi
+    content: "<ul><li>Your order is safe with us. Our checkout uses industry standard security to protect your information.</li><li>Your order will be billed immediately upon checkout.</li><li><b>ALL SALES ARE FINAL:</b> Defective or damaged product will be exchanged</li><li>All orders are processed expediently: usually in under 24 hours.</li></ul>"
+    created_at: 2005-04-04 12:00
+
+  - &page-5
+    id: 4
+    title: Shipping and Handling
+    handle: shipping
+    url: /pages/shipping
+    author: Tobi
+    content: <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
+    created_at: 2005-04-04 12:00
+
+  - &page-6
+    id: 5
+    title: Frontpage
+    handle: frontpage
+    url: /pages/frontpage
+    author: Tobi
+    content: <p>Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</p>
+    created_at: 2005-04-04 12:00
+
+blogs:
+  - id: 1
+    handle: news
+    title: News
+    url: /blogs/news
+    articles:
+      - id: 3
+        title: 'Welcome to the new Foo Shop'
+        author: Daniel
+        content: <p><strong>Welcome to your Shopify store! The jaded Pixel crew is really glad you decided to take Shopify for a spin.</strong></p><p>To help you get you started with Shopify, here are a couple of tips regarding what you see on this page.</p><p>The text you see here is an article. To edit this article, create new articles or create new pages you can go to the <a href="/admin/pages">Blogs &amp; Pages</a> tab of the administration menu.</p><p>The Shopify t-shirt above is a product and selling products is what Shopify is all about. To edit this product, or create new products you can go to the <a href="/admin/products">Products Tab</a> in of the administration menu.</p><p>While you're looking around be sure to check out the <a href="/admin/collections">Collections</a> and <a href="/admin/links">Navigations</a> tabs and soon you will be well on your way to populating your site.</p><p>And of course don't forget to browse the <a href="admin/design/appearance/themes">theme gallery</a> to pick a new look for your shop!</p><p><strong>Shopify is in beta</strong><br />If you would like to make comments or suggestions please visit us in the <a href="http://forums.shopify.com/community">Shopify Forums</a> or drop us an <a href="mailto:[email protected]">email</a>.</p>
+        created_at: 2005-04-04 16:00
+      - id: 4
+        title: 'Breaking News: Restock on all sales products'
+        author: Tobi
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-04 12:00
+    articles_count: 2
+
+  - id: 2
+    handle: bigcheese-blog
+    title: Bigcheese blog
+    url: /blogs/bigcheese-blog
+    articles:
+      - id: 1
+        title: 'One thing you probably did not know yet...'
+        author: Justin
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-04 16:00
+        comments:
+          -
+            id: 1
+            author: John Smith
+            email: [email protected]
+            content: Wow...great article man.
+            status: published
+            created_at: 2009-01-01 12:00
+            updated_at: 2009-02-01 12:00
+            url: ""
+          -
+            id: 2
+            author: John Jones
+            email: [email protected]
+            content: I really enjoyed this article. And I love your shop! It's awesome. Shopify rocks!
+            status: published
+            created_at: 2009-03-01 12:00
+            updated_at: 2009-02-01 12:00
+            url: "http://somesite.com/"
+      - id: 2
+        title: Fascinating
+        author: Tobi
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-06 12:00
+        comments:
+    articles_count: 2
+    comments_enabled?: true
+    comment_post_url: ""
+    comments_count: 2
+    moderated?: true
+
+  - id: 3
+    handle: paginated-blog
+    title: Paginated blog
+    url: /blogs/paginated-blog
+    articles:
+      - id: 6
+        title: 'One thing you probably did not know yet...'
+        author: Justin
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-04 16:00
+
+      - id: 7
+        title: Fascinating
+        author: Tobi
+        content: Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.
+        created_at: 2005-04-06 12:00
+    articles_count: 200

lib/liquid.rb

@@ -36,12 +36,14 @@ module Liquid
   VariableIncompleteEnd       = /\}\}?/
   QuotedString                = /"[^"]*"|'[^']*'/
   QuotedFragment              = /#{QuotedString}|(?:[^\s,\|'"]|#{QuotedString})+/o
-  TagAttributes               = /(\w+)\s*\:\s*(#{QuotedFragment})/o
+  TagAttributes               = /(\w[\w-]*)\s*\:\s*(#{QuotedFragment})/o
   AnyStartingTag              = /#{TagStart}|#{VariableStart}/o
   PartialTemplateParser       = /#{TagStart}.*?#{TagEnd}|#{VariableStart}.*?#{VariableIncompleteEnd}/om
   TemplateParser              = /(#{PartialTemplateParser}|#{AnyStartingTag})/om
   VariableParser              = /\[[^\]]+\]|#{VariableSegment}+\??/o
 
+  RAISE_EXCEPTION_LAMBDA = ->(_e) { raise }
+
   singleton_class.send(:attr_accessor, :cache_classes)
   self.cache_classes = true
 end
@@ -57,11 +59,14 @@ require 'liquid/forloop_drop'
 require 'liquid/extensions'
 require 'liquid/errors'
 require 'liquid/interrupts'
-require 'liquid/strainer'
+require 'liquid/strainer_template'
+require 'liquid/strainer_factory'
 require 'liquid/expression'
 require 'liquid/context'
 require 'liquid/parser_switching'
 require 'liquid/tag'
+require 'liquid/tag/disabler'
+require 'liquid/tag/disableable'
 require 'liquid/block'
 require 'liquid/block_body'
 require 'liquid/document'
@@ -80,8 +85,8 @@ require 'liquid/partial_cache'
 require 'liquid/usage'
 require 'liquid/register'
 require 'liquid/static_registers'
+require 'liquid/template_factory'
 
 # Load all the tags of the standard library
 #
 Dir["#{__dir__}/liquid/tags/*.rb"].each { |f| require f }
-Dir["#{__dir__}/liquid/registers/*.rb"].each { |f| require f }

lib/liquid/block.rb

@@ -10,9 +10,10 @@ module Liquid
     end
 
     def parse(tokens)
-      @body = BlockBody.new
+      @body = new_body
       while parse_body(@body, tokens)
       end
+      @body.freeze
     end
 
     # For backwards compatibility
@@ -28,7 +29,12 @@ module Liquid
       @body.nodelist
     end
 
-    def unknown_tag(tag, _params, _tokens)
+    def unknown_tag(tag_name, _markup, _tokenizer)
+      Block.raise_unknown_tag(tag_name, block_name, block_delimiter, parse_context)
+    end
+
+    # @api private
+    def self.raise_unknown_tag(tag, block_name, block_delimiter, parse_context)
       if tag == 'else'
         raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_else",
           block_name: block_name)
@@ -42,6 +48,10 @@ module Liquid
       end
     end
 
+    def raise_tag_never_closed(block_name)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+    end
+
     def block_name
       @tag_name
     end
@@ -50,8 +60,14 @@ module Liquid
       @block_delimiter ||= "end#{block_name}"
     end
 
-    protected
+    private
 
+    # @api public
+    def new_body
+      parse_context.new_block_body
+    end
+
+    # @api public
     def parse_body(body, tokens)
       if parse_context.depth >= MAX_DEPTH
         raise StackLevelError, "Nesting too deep"
@@ -62,9 +78,7 @@ module Liquid
           @blank &&= body.blank?
 
           return false if end_tag_name == block_delimiter
-          unless end_tag_name
-            raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
-          end
+          raise_tag_never_closed(block_name) unless end_tag_name
 
           # 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,22 +1,26 @@
 # frozen_string_literal: true
 
+require 'English'
+
 module Liquid
   class BlockBody
-    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
+    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 = "{%"
-    VARSTART = "{{"
+    TAGSTART            = "{%"
+    VARSTART            = "{{"
 
     attr_reader :nodelist
 
     def initialize
       @nodelist = []
-      @blank = true
+      @blank    = true
     end
 
     def parse(tokenizer, parse_context, &block)
+      raise FrozenError, "can't modify frozen Liquid::BlockBody" if frozen?
+
       parse_context.line_number = tokenizer.line_number
 
       if tokenizer.for_liquid_tag
@@ -26,16 +30,21 @@ module Liquid
       end
     end
 
+    def freeze
+      @nodelist.freeze
+      super
+    end
+
     private def parse_for_liquid_tag(tokenizer, parse_context)
       while (token = tokenizer.shift)
-        unless token.empty? || token =~ WhitespaceOrNothing
+        unless token.empty? || token.match?(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)
+          markup   = Regexp.last_match(2)
           unless (tag = registered_tags[tag_name])
             # end parsing if we reach an unknown tag and let the caller decide
             # determine how to proceed
@@ -51,17 +60,66 @@ module Liquid
       yield nil, nil
     end
 
-    private def parse_for_document(tokenizer, parse_context, &block)
+    # @api private
+    def self.unknown_tag_in_liquid_tag(tag, parse_context)
+      Block.raise_unknown_tag(tag, 'liquid', '%}', parse_context)
+    end
+
+    # @api private
+    def self.raise_missing_tag_terminator(token, parse_context)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
+    end
+
+    # @api private
+    def self.raise_missing_variable_terminator(token, parse_context)
+      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
+    end
+
+    # @api private
+    def self.render_node(context, output, node)
+      node.render_to_output_buffer(context, output)
+    rescue => exc
+      blank_tag = !node.instance_of?(Variable) && node.blank?
+      rescue_render_node(context, output, node.line_number, exc, blank_tag)
+    end
+
+    # @api private
+    def self.rescue_render_node(context, output, line_number, exc, blank_tag)
+      case exc
+      when MemoryError
+        raise
+      when UndefinedVariable, UndefinedDropMethod, UndefinedFilter
+        context.handle_error(exc, line_number)
+      else
+        error_message = context.handle_error(exc, line_number)
+        unless blank_tag # conditional for backwards compatibility
+          output << error_message
+        end
+      end
+    end
+
+    private def parse_liquid_tag(markup, parse_context)
+      liquid_tag_tokenizer = parse_context.new_tokenizer(
+        markup, start_line_number: parse_context.line_number, for_liquid_tag: true
+      )
+      parse_for_liquid_tag(liquid_tag_tokenizer, parse_context) do |end_tag_name, _end_tag_markup|
+        if end_tag_name
+          BlockBody.unknown_tag_in_liquid_tag(end_tag_name, parse_context)
+        end
+      end
+    end
+
+    private def parse_for_document(tokenizer, parse_context)
       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)
+            BlockBody.raise_missing_tag_terminator(token, parse_context)
           end
           tag_name = Regexp.last_match(2)
-          markup = Regexp.last_match(4)
+          markup   = Regexp.last_match(4)
 
           if parse_context.line_number
             # newlines inside the tag should increase the line number,
@@ -70,8 +128,8 @@ module Liquid
           end
 
           if tag_name == 'liquid'
-            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)
+            parse_liquid_tag(markup, parse_context)
+            next
           end
 
           unless (tag = registered_tags[tag_name])
@@ -92,7 +150,7 @@ module Liquid
           end
           parse_context.trim_whitespace = false
           @nodelist << token
-          @blank &&= !!(token =~ WhitespaceOrNothing)
+          @blank &&= token.match?(WhitespaceOrNothing)
         end
         parse_context.line_number = tokenizer.line_number
       end
@@ -104,7 +162,11 @@ module Liquid
       if token[2] == WhitespaceControl
         previous_token = @nodelist.last
         if previous_token.is_a?(String)
+          first_byte = previous_token.getbyte(0)
           previous_token.rstrip!
+          if previous_token.empty? && parse_context[:bug_compatible_whitespace_trimming] && first_byte
+            previous_token << first_byte
+          end
         end
       end
       parse_context.trim_whitespace = (token[-3] == WhitespaceControl)
@@ -114,38 +176,49 @@ module Liquid
       @blank
     end
 
+    # Remove blank strings in the block body for a control flow tag (e.g. `if`, `for`, `case`, `unless`)
+    # with a blank body.
+    #
+    # For example, in a conditional assignment like the following
+    #
+    # ```
+    # {% if size > max_size %}
+    #   {% assign size = max_size %}
+    # {% endif %}
+    # ```
+    #
+    # we assume the intention wasn't to output the blank spaces in the `if` tag's block body, so this method
+    # will remove them to reduce the render output size.
+    #
+    # Note that it is now preferred to use the `liquid` tag for this use case.
+    def remove_blank_strings
+      raise "remove_blank_strings only support being called on a blank block body" unless @blank
+      @nodelist.reject! { |node| node.instance_of?(String) }
+    end
+
     def render(context)
       render_to_output_buffer(context, +'')
     end
 
     def render_to_output_buffer(context, output)
-      context.resource_limits.render_score += @nodelist.length
+      freeze unless frozen?
+
+      context.resource_limits.increment_render_score(@nodelist.length)
 
       idx = 0
       while (node = @nodelist[idx])
-        previous_output_size = output.bytesize
-
-        case node
-        when String
+        if node.instance_of?(String)
           output << node
-        when Variable
+        else
           render_node(context, output, node)
-        when Block
-          render_node(context, node.blank? ? +'' : output, node)
-          break if context.interrupt? # might have happened in a for-block
-        when Continue, Break
           # If we get an Interrupt that means the block must stop processing. An
           # Interrupt is any command that stops block execution such as {% break %}
-          # or {% continue %}
-          context.push_interrupt(node.interrupt)
-          break
-        else # Other non-Block tags
-          render_node(context, output, node)
-          break if context.interrupt? # might have happened through an include
+          # or {% continue %}. These tags may also occur through Block or Include tags.
+          break if context.interrupt? # might have happened in a for-block
         end
         idx += 1
 
-        raise_if_resource_limits_reached(context, output.bytesize - previous_output_size)
+        context.resource_limits.increment_write_score(output)
       end
 
       output
@@ -154,45 +227,25 @@ module Liquid
     private
 
     def render_node(context, output, node)
-      if node.disabled?(context)
-        output << node.disabled_error_message
-        return
-      end
-      disable_tags(context, node.disabled_tags) do
-        node.render_to_output_buffer(context, output)
-      end
-    rescue UndefinedVariable, UndefinedDropMethod, UndefinedFilter => e
-      context.handle_error(e, node.line_number)
-    rescue ::StandardError => e
-      line_number = node.is_a?(String) ? nil : node.line_number
-      output << context.handle_error(e, line_number)
-    end
-
-    def disable_tags(context, tags, &block)
-      return yield if tags.empty?
-      context.registers[:disabled_tags].disable(tags, &block)
-    end
-
-    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"
+      BlockBody.render_node(context, output, node)
     end
 
     def create_variable(token, parse_context)
-      token.scan(ContentOfVariable) do |content|
-        markup = content.first
+      if token =~ ContentOfVariable
+        markup = Regexp.last_match(1)
         return Variable.new(markup, parse_context)
       end
-      raise_missing_variable_terminator(token, parse_context)
+      BlockBody.raise_missing_variable_terminator(token, parse_context)
     end
 
+    # @deprecated Use {.raise_missing_tag_terminator} instead
     def raise_missing_tag_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_termination", token: token, tag_end: TagEnd.inspect)
+      BlockBody.raise_missing_tag_terminator(token, parse_context)
     end
 
+    # @deprecated Use {.raise_missing_variable_terminator} instead
     def raise_missing_variable_terminator(token, parse_context)
-      raise SyntaxError, parse_context.locale.t("errors.syntax.variable_termination", token: token, tag_end: VariableEnd.inspect)
+      BlockBody.raise_missing_variable_terminator(token, parse_context)
     end
 
     def registered_tags

lib/liquid/compile.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require 'pry-byebug'
+require 'set'
+
+module Liquid
+  class Compiler
+    def initialize
+      @ruby = +""
+      @nodes = {}
+      @declared = Set.new(['__l_product'])
+    end
+
+    def <<(line)
+      @ruby << line
+    end
+
+    def var_name(name)
+      "__l_#{name}"
+    end
+
+    def declare(name)
+      @declared << name
+    end
+
+    def declared?(name)
+      @declared.member?(name)
+    end
+
+    def to_proc
+      show_ruby = ENV["SHOW_RUBY"] && ENV["SHOW_RUBY"].to_i || 0
+      STDERR.puts @ruby if show_ruby >= 1
+      res = RubyVM::InstructionSequence.compile(<<~RUBY).eval.call(@nodes)
+      # frozen_string_literal: true
+      ->(__nodes) {
+        ->(__context, __output, __l_product) {
+          __assigns = __context.scopes.last
+          #{@ruby}
+          __output
+        }
+      }
+      RUBY
+
+      STDERR.puts RubyVM::InstructionSequence.disasm(res) if show_ruby >= 2
+      res
+    end
+
+    def compile_expr(node)
+      if node.respond_to?(:compile_expr)
+        node.compile_expr(self)
+      else
+        case node
+        when Range # returned by RangeLookup when range contains only literals
+          node.inspect
+        when Integer, Float, nil, true, false, String
+          node.inspect
+        else
+          raise ArgumentError, "cannot compile node #{node.inspect}"
+        end
+      end
+    end
+
+    def output(node)
+      compiled = compile_expr(node)
+      self << if compiled.is_a?(String)
+        "__output << #{compiled}\n"
+      else
+        "__output << #{compiled}.to_s\n"
+      end
+    end
+
+    def fallback_evaluate_expr(node)
+      "__nodes[#{node.object_id}].evaluate(__context)"
+    end
+
+    def to_integer_expr(var_name)
+      <<~RUBY.strip
+      (begin
+        if #{var_name}.is_a?(Integer)
+          #{var_name}
+        else
+          begin
+            Integer(#{var_name}.to_s)
+          rescue ::ArgumentError
+            raise Liquid::ArgumentError, "invalid integer"
+          end
+        end
+      end)
+      RUBY
+    end
+
+    def compile(node)
+      if node.instance_of?(String)
+        self << "__output << #{node.inspect}\n"
+      else
+        @nodes[node.object_id] = node
+        if node.respond_to?(:compile)
+          node.compile(self)
+        else
+          line_number = if node.respond_to?(:line_number) && node.line_number.is_a?(Integer)
+            node.line_number
+          else
+            nil
+          end
+          catch_errors(line_number, show_message: !node.blank?) do
+            self << "__nodes[#{node.object_id}].render_to_output_buffer(__context, __output) # #{node.inspect} \n"
+          end
+        end
+      end
+    end
+
+    def catch_errors(line_number, show_message: true)
+      self << "begin\n"
+      yield
+      self << <<~RUBY
+        rescue => __exc
+          case __exc
+          when Liquid::MemoryError
+            raise
+          when Liquid::UndefinedVariable, Liquid::UndefinedDropMethod, Liquid::UndefinedFilter
+            __context.handle_error(__exc, #{line_number.inspect})
+          else
+            __error_message = __context.handle_error(__exc, #{line_number.inspect})
+      RUBY
+      self << "__output << __error_message\n" if show_message
+      self << "end\nend\n"
+    end
+  end
+
+  class BlockBody
+    def render_to_output_buffer(context, output)
+      raise "Tried to render uncompiled block" unless @compiled
+      @compiled.call(context, output, context.environments[0][:product])
+    end
+
+    def compile_top_level
+      compiler = Compiler.new
+      compile(compiler)
+      @compiled = compiler.to_proc
+    end
+
+    def compile(compiler)
+      nodelist.each { |node| compiler.compile(node) }
+    end
+  end
+
+  class Document
+    def parse(tokenizer, parse_context)
+      while parse_body(tokenizer)
+      end
+      @body.compile_top_level
+      @body.freeze
+    rescue SyntaxError => e
+      e.line_number ||= parse_context.line_number
+      raise
+    end
+  end
+
+  class VariableLookup
+    def compile_expr(compiler)
+      # HACK
+      if @name == "forloop" && @lookups == ["first"]
+        return "forloop_first"
+      end
+
+      var_name = compiler.var_name(@name)
+      root = if compiler.declared?(var_name)
+        var_name
+      else
+        "__scope[#{@name.inspect}]"
+      end
+
+      @lookups.reduce(root) do |prev, lookup|
+        "#{prev}[:#{lookup}]"
+      end
+    end
+  end
+
+  class Variable
+    FILTERS = {
+      "modulo" => ->(compiler, expr, args, kwargs) {
+        "(#{expr} % #{args[0]})"
+      },
+      "product_img_url" => ->(compiler, expr, args, kwargs) {
+        style = args.fetch(0, 'small')
+
+        rest = case style
+        when 'original'
+          "\"/files/shops/random_number/\#{url}\""
+        when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
+          "\"/files/shops/random_number/products/\#{$1}_#{style}.\#{$2}\""
+        else
+          "raise ArgumentError, 'valid parameters for filter \"size\" are: original, grande, large, medium, compact, small, thumb and icon '"
+        end
+
+        <<~RUBY.strip
+        (begin
+          if #{expr} =~ %r{\\Aproducts/([\\w\\-\\_]+)\\.(\\w{2,4})}
+            #{rest}
+          else
+            raise ArgumentError, 'filter \"size\" can only be called on product images'
+          end
+        end)
+        RUBY
+      },
+      "escape" => ->(compiler, expr, args, kwargs) {
+        "(_t = #{expr}; CGI.escapeHTML(_t) if _t)"
+      },
+      "money" => ->(compiler, expr, args, kwargs) {
+        "(_m = #{expr}; _m.nil? ? '' : \"$ \#{(_m / 100.0).round(2)}\")"
+      },
+    }
+
+    def compile(compiler)
+      if const?
+        compiler.output(name)
+      else
+        compiler.catch_errors(@line_number, show_message: true) do
+          compiler.output(self)
+        end
+      end
+    end
+
+    def const?
+      @filters.empty? && !name.respond_to?(:compile_expr)
+    end
+
+    def compile_expr(compiler)
+      @filters.reduce(compiler.compile_expr(name)) do |expr, (name, args, kwargs)|
+        if FILTERS.key?(name)
+          FILTERS[name].call(compiler, expr, args, kwargs)
+        else
+          expr
+        end
+      end
+    end
+  end
+
+  class Echo
+    def compile(compiler)
+      compiler.compile(variable)
+    end
+  end
+
+  class For
+    def compile(compiler)
+      compiler << "collection = #{compiler.compile_expr(@collection_name)}\n"
+    
+      unless @from.nil?
+        compiler << <<~RUBY
+          from_value = #{compiler.compile_expr(@from)}
+          from = if from_value.nil?
+            0
+          else
+            #{compiler.to_integer_expr(:from_value)}
+          end
+
+          limit_value = #{compiler.compile_expr(@limit)}
+          to = if limit_value.nil?
+            nil
+          else
+            #{compiler.to_integer_expr(:limit_value)} + from
+          end
+
+          collection = #{compiler.slice_collection_expr(:collection, :from, :to)}
+          #{@reversed ? "segment.reverse!" : "" }
+        RUBY
+      end
+
+      item_var = compiler.var_name(variable_name)
+      compiler << <<~RUBY
+        forloop_first = true
+        for #{item_var} in collection
+      RUBY
+      compiler.declare(item_var)
+      compiler.compile(@for_block)
+      compiler << <<~RUBY
+          forloop_first = false
+        end
+      RUBY
+
+    end
+  end
+
+  class If
+    def compile(compiler)
+      compiler << "if #{compiler.compile_expr(blocks[0])}\n"
+      compiler.compile(blocks[0].attachment)
+      blocks.drop(1).each do |block|
+        if block.else?
+          compiler << "else\n"
+        else
+          compiler << "elsif #{block.compile_expr(compiler)}\n"
+        end
+        compiler.compile(block.attachment)
+      end
+      compiler << "end\n"
+    end
+  end
+
+  class Comment
+    def compile(_compiler); end
+  end
+
+  class Condition
+    def compile_expr(compiler)
+      if operator
+        left_expr = compiler.compile_expr(left)
+        right_expr = compiler.compile_expr(right)
+        if child_relation
+          child_expr = compiler.compile_expr(child_condition)
+          expr = "((#{left_expr} #{operator} #{right_expr}) #{child_relation} #{child_expr})"
+        else
+          expr = "(#{left_expr} #{operator} #{right_expr})"
+        end
+        expr
+      else
+        left_expr = compiler.compile_expr(left)
+        expr = "#{left_expr}"
+      end
+    end
+  end
+
+  class Assign
+    def compile(compiler)
+      compiler.declare(compiler.var_name(@to))
+      compiler << "#{compiler.var_name(@to)} = #{compiler.compile_expr(@from)}\n"
+    end
+  end
+end

lib/liquid/condition.rb

@@ -8,7 +8,7 @@ module Liquid
   #   c = Condition.new(1, '==', 1)
   #   c.evaluate #=> true
   #
-  class Condition #:nodoc:
+  class Condition # :nodoc:
     @@operators = {
       '==' => ->(cond, left, right) {  cond.send(:equal_variables, left, right) },
       '!=' => ->(cond, left, right) { !cond.send(:equal_variables, left, right) },
@@ -27,22 +27,41 @@ module Liquid
       end,
     }
 
+    class MethodLiteral
+      attr_reader :method_name, :to_s
+
+      def initialize(method_name, to_s)
+        @method_name = method_name
+        @to_s = to_s
+      end
+    end
+
+    @@method_literals = {
+      'blank' => MethodLiteral.new(:blank?, '').freeze,
+      'empty' => MethodLiteral.new(:empty?, '').freeze,
+    }
+
     def self.operators
       @@operators
     end
 
+    def self.parse_expression(parse_context, markup)
+      @@method_literals[markup] || parse_context.parse_expression(markup)
+    end
+
     attr_reader :attachment, :child_condition
     attr_accessor :left, :operator, :right
 
     def initialize(left = nil, operator = nil, right = nil)
-      @left = left
+      @left     = left
       @operator = operator
-      @right = right
-      @child_relation = nil
+      @right    = right
+
+      @child_relation  = nil
       @child_condition = nil
     end
 
-    def evaluate(context = Context.new)
+    def evaluate(context = deprecated_default_context)
       condition = self
       result = nil
       loop do
@@ -62,12 +81,12 @@ module Liquid
     end
 
     def or(condition)
-      @child_relation = :or
+      @child_relation  = :or
       @child_condition = condition
     end
 
     def and(condition)
-      @child_relation = :and
+      @child_relation  = :and
       @child_condition = condition
     end
 
@@ -90,7 +109,7 @@ module Liquid
     private
 
     def equal_variables(left, right)
-      if left.is_a?(Liquid::Expression::MethodLiteral)
+      if left.is_a?(MethodLiteral)
         if right.respond_to?(left.method_name)
           return right.send(left.method_name)
         else
@@ -98,7 +117,7 @@ module Liquid
         end
       end
 
-      if right.is_a?(Liquid::Expression::MethodLiteral)
+      if right.is_a?(MethodLiteral)
         if left.respond_to?(right.method_name)
           return left.send(right.method_name)
         else
@@ -115,8 +134,8 @@ module Liquid
       # return this as the result.
       return context.evaluate(left) if op.nil?
 
-      left = context.evaluate(left)
-      right = context.evaluate(right)
+      left  = Liquid::Utils.to_liquid_value(context.evaluate(left))
+      right = Liquid::Utils.to_liquid_value(context.evaluate(right))
 
       operation = self.class.operators[op] || raise(Liquid::ArgumentError, "Unknown operator #{op}")
 
@@ -131,6 +150,12 @@ module Liquid
       end
     end
 
+    def deprecated_default_context
+      warn("DEPRECATION WARNING: Condition#evaluate without a context argument is deprecated" \
+        " and will be removed from Liquid 6.0.0.")
+      Context.new
+    end
+
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [

lib/liquid/context.rb

@@ -18,8 +18,8 @@ module Liquid
     attr_accessor :exception_renderer, :template_name, :partial, :global_filter, :strict_variables, :strict_filters
 
     # rubocop:disable Metrics/ParameterLists
-    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {})
-      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments)
+    def self.build(environments: {}, outer_scope: {}, registers: {}, rethrow_errors: false, resource_limits: nil, static_environments: {}, &block)
+      new(environments, outer_scope, registers, rethrow_errors, resource_limits, static_environments, &block)
     end
 
     def initialize(environments = {}, outer_scope = {}, registers = {}, rethrow_errors = false, resource_limits = nil, static_environments = {})
@@ -34,16 +34,20 @@ module Liquid
       @strict_variables    = false
       @resource_limits     = resource_limits || ResourceLimits.new(Template.default_resource_limits)
       @base_scope_depth    = 0
-      squash_instance_assigns_with_environments
+      @interrupts          = []
+      @filters             = []
+      @global_filter       = nil
+      @disabled_tags       = {}
 
       self.exception_renderer = Template.default_exception_renderer
       if rethrow_errors
-        self.exception_renderer = ->(_e) { raise }
+        self.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
       end
 
-      @interrupts = []
-      @filters = []
-      @global_filter = nil
+      yield self if block_given?
+
+      # Do this last, since it could result in this object being passed to a Proc in the environment
+      squash_instance_assigns_with_environments
     end
     # rubocop:enable Metrics/ParameterLists
 
@@ -52,7 +56,7 @@ module Liquid
     end
 
     def strainer
-      @strainer ||= Strainer.create(self, @filters)
+      @strainer ||= StrainerFactory.create(self, @filters)
     end
 
     # Adds filters to this context.
@@ -87,7 +91,7 @@ module Liquid
     def handle_error(e, line_number = nil)
       e = internal_error unless e.is_a?(Liquid::Error)
       e.template_name ||= template_name
-      e.line_number ||= line_number
+      e.line_number   ||= line_number
       errors.push(e)
       exception_renderer.call(e).to_s
     end
@@ -120,7 +124,7 @@ module Liquid
     #      context['var'] = 'hi'
     #   end
     #
-    #   context['var]  #=> nil
+    #   context['var']  #=> nil
     def stack(new_scope = {})
       push(new_scope)
       yield
@@ -133,17 +137,18 @@ module Liquid
     def new_isolated_subcontext
       check_overflow
 
-      Context.build(
+      self.class.build(
         resource_limits: resource_limits,
         static_environments: static_environments,
         registers: StaticRegisters.new(registers)
       ).tap do |subcontext|
-        subcontext.base_scope_depth = base_scope_depth + 1
+        subcontext.base_scope_depth   = base_scope_depth + 1
         subcontext.exception_renderer = exception_renderer
-        subcontext.filters = @filters
+        subcontext.filters  = @filters
         subcontext.strainer = nil
-        subcontext.errors = errors
+        subcontext.errors   = errors
         subcontext.warnings = warnings
+        subcontext.disabled_tags = @disabled_tags
       end
     end
 
@@ -188,7 +193,7 @@ module Liquid
         try_variable_find_in_environments(key, raise_on_not_found: raise_on_not_found)
       end
 
-      variable = variable.to_liquid
+      variable         = variable.to_liquid
       variable.context = self if variable.respond_to?(:context=)
 
       variable
@@ -208,9 +213,24 @@ module Liquid
       end
     end
 
+    def with_disabled_tags(tag_names)
+      tag_names.each do |name|
+        @disabled_tags[name] = @disabled_tags.fetch(name, 0) + 1
+      end
+      yield
+    ensure
+      tag_names.each do |name|
+        @disabled_tags[name] -= 1
+      end
+    end
+
+    def tag_disabled?(tag_name)
+      @disabled_tags.fetch(tag_name, 0) > 0
+    end
+
     protected
 
-    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters
+    attr_writer :base_scope_depth, :warnings, :errors, :strainer, :filters, :disabled_tags
 
     private
 

lib/liquid/document.rb

@@ -1,23 +1,34 @@
 # frozen_string_literal: true
 
 module Liquid
-  class Document < BlockBody
+  class Document
     def self.parse(tokens, parse_context)
-      doc = new
+      doc = new(parse_context)
       doc.parse(tokens, parse_context)
       doc
     end
 
-    def parse(tokens, parse_context)
-      super do |end_tag_name, _end_tag_params|
-        unknown_tag(end_tag_name, parse_context) if end_tag_name
+    attr_reader :parse_context, :body
+
+    def initialize(parse_context)
+      @parse_context = parse_context
+      @body = new_body
+    end
+
+    def nodelist
+      @body.nodelist
+    end
+
+    def parse(tokenizer, parse_context)
+      while parse_body(tokenizer)
       end
+      @body.freeze
     rescue SyntaxError => e
       e.line_number ||= parse_context.line_number
       raise
     end
 
-    def unknown_tag(tag, parse_context)
+    def unknown_tag(tag, _markup, _tokenizer)
       case tag
       when 'else', 'end'
         raise SyntaxError, parse_context.locale.t("errors.syntax.unexpected_outer_tag", tag: tag)
@@ -25,5 +36,30 @@ module Liquid
         raise SyntaxError, parse_context.locale.t("errors.syntax.unknown_tag", tag: tag)
       end
     end
+
+    def render_to_output_buffer(context, output)
+      @body.render_to_output_buffer(context, output)
+    end
+
+    def render(context)
+      render_to_output_buffer(context, +'')
+    end
+
+    private
+
+    def new_body
+      parse_context.new_block_body
+    end
+
+    def parse_body(tokenizer)
+      @body.parse(tokenizer, parse_context) do |unknown_tag_name, unknown_tag_markup|
+        if unknown_tag_name
+          unknown_tag(unknown_tag_name, unknown_tag_markup, tokenizer)
+          true
+        else
+          false
+        end
+      end
+    end
   end
 end

lib/liquid/errors.rb

@@ -40,19 +40,19 @@ module Liquid
     end
   end
 
-  ArgumentError = Class.new(Error)
-  ContextError = Class.new(Error)
-  FileSystemError = Class.new(Error)
-  StandardError = Class.new(Error)
-  SyntaxError = Class.new(Error)
-  StackLevelError = Class.new(Error)
-  TaintedError = Class.new(Error)
-  MemoryError = Class.new(Error)
-  ZeroDivisionError = Class.new(Error)
-  FloatDomainError = Class.new(Error)
-  UndefinedVariable = Class.new(Error)
+  ArgumentError       = Class.new(Error)
+  ContextError        = Class.new(Error)
+  FileSystemError     = Class.new(Error)
+  StandardError       = Class.new(Error)
+  SyntaxError         = Class.new(Error)
+  StackLevelError     = Class.new(Error)
+  MemoryError         = Class.new(Error)
+  ZeroDivisionError   = Class.new(Error)
+  FloatDomainError    = Class.new(Error)
+  UndefinedVariable   = Class.new(Error)
   UndefinedDropMethod = Class.new(Error)
-  UndefinedFilter = Class.new(Error)
+  UndefinedFilter     = Class.new(Error)
   MethodOverrideError = Class.new(Error)
-  InternalError = Class.new(Error)
+  DisabledError       = Class.new(Error)
+  InternalError       = Class.new(Error)
 end

lib/liquid/expression.rb

@@ -2,46 +2,40 @@
 
 module Liquid
   class Expression
-    class MethodLiteral
-      attr_reader :method_name, :to_s
-
-      def initialize(method_name, to_s)
-        @method_name = method_name
-        @to_s = to_s
-      end
-
-      def to_liquid
-        to_s
-      end
-    end
-
     LITERALS = {
       nil => nil, 'nil' => nil, 'null' => nil, '' => nil,
       'true' => true,
       'false' => false,
-      'blank' => MethodLiteral.new(:blank?, '').freeze,
-      'empty' => MethodLiteral.new(:empty?, '').freeze
+      'blank' => '',
+      'empty' => ''
     }.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/
+
+    # Use an atomic group (?>...) to avoid pathological backtracing from
+    # malicious input as described in https://github.com/Shopify/liquid/issues/1357
+    RANGES_REGEX         = /\A\(\s*(?>(\S+)\s*\.\.)\s*(\S+)\s*\)\z/
 
     def self.parse(markup)
-      if LITERALS.key?(markup)
-        LITERALS[markup]
+      return nil unless markup
+
+      markup = markup.strip
+      if (markup.start_with?('"') && markup.end_with?('"')) ||
+         (markup.start_with?("'") && markup.end_with?("'"))
+        return markup[1..-2]
+      end
+
+      case markup
+      when INTEGERS_REGEX
+        Regexp.last_match(1).to_i
+      when RANGES_REGEX
+        RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
+      when FLOATS_REGEX
+        Regexp.last_match(1).to_f
       else
-        case markup
-        when SINGLE_QUOTED_STRING, DOUBLE_QUOTED_STRING
-          Regexp.last_match(1)
-        when INTEGERS_REGEX
-          Regexp.last_match(1).to_i
-        when RANGES_REGEX
-          RangeLookup.parse(Regexp.last_match(1), Regexp.last_match(2))
-        when FLOATS_REGEX
-          Regexp.last_match(1).to_f
+        if LITERALS.key?(markup)
+          LITERALS[markup]
         else
           VariableLookup.parse(markup)
         end

lib/liquid/file_system.rb

@@ -47,7 +47,7 @@ module Liquid
     attr_accessor :root
 
     def initialize(root, pattern = "_%s.liquid")
-      @root = root
+      @root    = root
       @pattern = pattern
     end
 

lib/liquid/forloop_drop.rb

@@ -3,13 +3,18 @@
 module Liquid
   class ForloopDrop < Drop
     def initialize(name, length, parentloop)
-      @name = name
-      @length = length
+      @name       = name
+      @length     = length
       @parentloop = parentloop
-      @index = 0
+      @index      = 0
     end
 
-    attr_reader :name, :length, :parentloop
+    attr_reader :length, :parentloop
+
+    def name
+      Usage.increment('forloop_drop_name')
+      @name
+    end
 
     def index
       @index + 1

lib/liquid/lexer.rb

@@ -15,12 +15,12 @@ module Liquid
       '?' => :question,
       '-' => :dash,
     }.freeze
-    IDENTIFIER = /[a-zA-Z_][\w-]*\??/
+    IDENTIFIER            = /[a-zA-Z_][\w-]*\??/
     SINGLE_STRING_LITERAL = /'[^\']*'/
     DOUBLE_STRING_LITERAL = /"[^\"]*"/
-    NUMBER_LITERAL = /-?\d+(\.\d+)?/
-    DOTDOT = /\.\./
-    COMPARISON_OPERATOR = /==|!=|<>|<=?|>=?|contains(?=\s)/
+    NUMBER_LITERAL        = /-?\d+(\.\d+)?/
+    DOTDOT                = /\.\./
+    COMPARISON_OPERATOR   = /==|!=|<>|<=?|>=?|contains(?=\s)/
     WHITESPACE_OR_NOTHING = /\s*/
 
     def initialize(input)
@@ -33,7 +33,7 @@ module Liquid
       until @ss.eos?
         @ss.skip(WHITESPACE_OR_NOTHING)
         break if @ss.eos?
-        tok = if (t = @ss.scan(COMPARISON_OPERATOR))
+        tok      = if (t = @ss.scan(COMPARISON_OPERATOR))
           [:comparison, t]
         elsif (t = @ss.scan(SINGLE_STRING_LITERAL))
           [:string, t]
@@ -46,7 +46,7 @@ module Liquid
         elsif (t = @ss.scan(DOTDOT))
           [:dotdot, t]
         else
-          c = @ss.getch
+          c     = @ss.getch
           if (s = SPECIALS[c])
             [s, c]
           else

lib/liquid/locales/en.yml

@@ -20,7 +20,6 @@
       tag_termination: "Tag '%{token}' was not properly terminated with regexp: %{tag_end}"
       variable_termination: "Variable '%{token}' was not properly terminated with regexp: %{tag_end}"
       tag_never_closed: "'%{block_name}' tag was never closed"
-      meta_syntax_error: "Liquid syntax error: #{e.message}"
       table_row: "Syntax Error in 'table_row loop' - Valid syntax: table_row [item] in [collection] cols=3"
       render: "Syntax error in tag 'render' - Template name must be a quoted string"
     argument:

lib/liquid/parse_context.rb

@@ -7,9 +7,11 @@ module Liquid
 
     def initialize(options = {})
       @template_options = options ? options.dup : {}
-      @locale = @template_options[:locale] ||= I18n.new
+
+      @locale   = @template_options[:locale] ||= I18n.new
       @warnings = []
-      self.depth = 0
+
+      self.depth   = 0
       self.partial = false
     end
 
@@ -17,9 +19,22 @@ module Liquid
       @options[option_key]
     end
 
+    def new_block_body
+      Liquid::BlockBody.new
+    end
+
+    def new_tokenizer(markup, start_line_number: nil, for_liquid_tag: false)
+      Tokenizer.new(markup, line_number: start_line_number, for_liquid_tag: for_liquid_tag)
+    end
+
+    def parse_expression(markup)
+      Expression.parse(markup)
+    end
+
     def partial=(value)
       @partial = value
       @options = value ? partial_options : @template_options
+
       @error_mode = @options[:error_mode] || Template.error_mode
     end
 

lib/liquid/parse_tree_visitor.rb

@@ -11,7 +11,7 @@ module Liquid
     end
 
     def initialize(node, callbacks)
-      @node = node
+      @node      = node
       @callbacks = callbacks
     end
 

lib/liquid/parser.rb

@@ -3,9 +3,9 @@
 module Liquid
   class Parser
     def initialize(input)
-      l = Lexer.new(input)
+      l       = Lexer.new(input)
       @tokens = l.tokenize
-      @p = 0 # pointer to current location
+      @p      = 0 # pointer to current location
     end
 
     def jump(point)
@@ -46,16 +46,20 @@ module Liquid
       tok[0] == type
     end
 
-    SINGLE_TOKEN_EXPRESSION_TYPES = [:string, :number].freeze
-    private_constant :SINGLE_TOKEN_EXPRESSION_TYPES
-
     def expression
       token = @tokens[@p]
-      if token[0] == :id
-        variable_signature
-      elsif SINGLE_TOKEN_EXPRESSION_TYPES.include?(token[0])
+      case token[0]
+      when :id
+        str = consume
+        str << variable_lookups
+      when :open_square
+        str = consume
+        str << expression
+        str << consume(:close_square)
+        str << variable_lookups
+      when :string, :number
         consume
-      elsif token.first == :open_round
+      when :open_round
         consume
         first = expression
         consume(:dotdot)
@@ -78,16 +82,19 @@ module Liquid
       str
     end
 
-    def variable_signature
-      str = consume(:id)
-      while look(:open_square)
-        str << consume
-        str << expression
-        str << consume(:close_square)
-      end
-      if look(:dot)
-        str << consume
-        str << variable_signature
+    def variable_lookups
+      str = +""
+      loop do
+        if look(:open_square)
+          str << consume
+          str << expression
+          str << consume(:close_square)
+        elsif look(:dot)
+          str << consume
+          str << consume(:id)
+        else
+          break
+        end
       end
       str
     end

lib/liquid/parser_switching.rb

@@ -2,16 +2,28 @@
 
 module Liquid
   module ParserSwitching
+    def strict_parse_with_error_mode_fallback(markup)
+      strict_parse_with_error_context(markup)
+    rescue SyntaxError => e
+      case parse_context.error_mode
+      when :strict
+        raise
+      when :warn
+        parse_context.warnings << e
+      end
+      lax_parse(markup)
+    end
+
     def parse_with_selected_parser(markup)
       case parse_context.error_mode
       when :strict then strict_parse_with_error_context(markup)
       when :lax    then lax_parse(markup)
       when :warn
         begin
-          return strict_parse_with_error_context(markup)
+          strict_parse_with_error_context(markup)
         rescue SyntaxError => e
           parse_context.warnings << e
-          return lax_parse(markup)
+          lax_parse(markup)
         end
       end
     end
@@ -21,7 +33,7 @@ module Liquid
     def strict_parse_with_error_context(markup)
       strict_parse(markup)
     rescue SyntaxError => e
-      e.line_number = line_number
+      e.line_number    = line_number
       e.markup_context = markup_context(markup)
       raise e
     end

lib/liquid/partial_cache.rb

@@ -8,10 +8,14 @@ module Liquid
       return cached if cached
 
       file_system = (context.registers[:file_system] ||= Liquid::Template.file_system)
-      source = file_system.read_template_file(template_name)
+      source      = file_system.read_template_file(template_name)
+
       parse_context.partial = true
 
-      partial = Liquid::Template.parse(source, parse_context)
+      template_factory = (context.registers[:template_factory] ||= Liquid::TemplateFactory.new)
+      template = template_factory.for(template_name)
+
+      partial = template.parse(source, parse_context)
       cached_partials[template_name] = partial
     ensure
       parse_context.partial = false

lib/liquid/profiler.rb

@@ -25,7 +25,7 @@ module Liquid
   #     node.code
   #
   #     # Which template and line number of this node.
-  #     # If top level, this will be "<root>".
+  #     # The top-level template name is `nil` by default, but can be set in the Liquid::Context before rendering.
   #     node.partial
   #     node.line_number
   #
@@ -46,115 +46,94 @@ module Liquid
     include Enumerable
 
     class Timing
-      attr_reader :code, :partial, :line_number, :children
+      attr_reader :code, :template_name, :line_number, :children
+      attr_accessor :total_time
+      alias_method :render_time, :total_time
+      alias_method :partial, :template_name
 
-      def initialize(node, partial)
-        @code        = node.respond_to?(:raw) ? node.raw : node
-        @partial     = partial
-        @line_number = node.respond_to?(:line_number) ? node.line_number : nil
-        @children    = []
+      def initialize(code: nil, template_name: nil, line_number: nil)
+        @code = code
+        @template_name = template_name
+        @line_number = line_number
+        @children = []
       end
 
-      def self.start(node, partial)
-        new(node, partial).tap(&:start)
-      end
-
-      def start
-        @start_time = Time.now
-      end
-
-      def finish
-        @end_time = Time.now
-      end
-
-      def render_time
-        @end_time - @start_time
+      def self_time
+        @self_time ||= begin
+          total_children_time = 0.0
+          @children.each do |child|
+            total_children_time += child.total_time
+          end
+          @total_time - total_children_time
+        end
       end
     end
 
-    def self.profile_node_render(node)
-      if Profiler.current_profile && node.respond_to?(:render)
-        Profiler.current_profile.start_node(node)
-        output = yield
-        Profiler.current_profile.end_node(node)
-        output
-      else
-        yield
-      end
-    end
-
-    def self.profile_children(template_name)
-      if Profiler.current_profile
-        Profiler.current_profile.push_partial(template_name)
-        output = yield
-        Profiler.current_profile.pop_partial
-        output
-      else
-        yield
-      end
-    end
-
-    def self.current_profile
-      Thread.current[:liquid_profiler]
-    end
+    attr_reader :total_time
+    alias_method :total_render_time, :total_time
 
     def initialize
-      @partial_stack = ["<root>"]
-
-      @root_timing = Timing.new("", current_partial)
-      @timing_stack = [@root_timing]
-
-      @render_start_at = Time.now
-      @render_end_at = @render_start_at
+      @root_children = []
+      @current_children = nil
+      @total_time = 0.0
     end
 
-    def start
-      Thread.current[:liquid_profiler] = self
-      @render_start_at = Time.now
+    def profile(template_name, &block)
+      # nested renders are done from a tag that already has a timing node
+      return yield if @current_children
+
+      root_children = @root_children
+      render_idx = root_children.length
+      begin
+        @current_children = root_children
+        profile_node(template_name, &block)
+      ensure
+        @current_children = nil
+        if (timing = root_children[render_idx])
+          @total_time += timing.total_time
+        end
+      end
     end
 
-    def stop
-      Thread.current[:liquid_profiler] = nil
-      @render_end_at = Time.now
-    end
-
-    def total_render_time
-      @render_end_at - @render_start_at
+    def children
+      children = @root_children
+      if children.length == 1
+        children.first.children
+      else
+        children
+      end
     end
 
     def each(&block)
-      @root_timing.children.each(&block)
+      children.each(&block)
     end
 
     def [](idx)
-      @root_timing.children[idx]
+      children[idx]
     end
 
     def length
-      @root_timing.children.length
+      children.length
     end
 
-    def start_node(node)
-      @timing_stack.push(Timing.start(node, current_partial))
+    def profile_node(template_name, code: nil, line_number: nil)
+      timing = Timing.new(code: code, template_name: template_name, line_number: line_number)
+      parent_children = @current_children
+      start_time = monotonic_time
+      begin
+        @current_children = timing.children
+        yield
+      ensure
+        @current_children = parent_children
+        timing.total_time = monotonic_time - start_time
+        parent_children << timing
+      end
     end
 
-    def end_node(_node)
-      timing = @timing_stack.pop
-      timing.finish
+    private
 
-      @timing_stack.last.children << timing
-    end
-
-    def current_partial
-      @partial_stack.last
-    end
-
-    def push_partial(partial_name)
-      @partial_stack.push(partial_name)
-    end
-
-    def pop_partial
-      @partial_stack.pop
+    def monotonic_time
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
   end
 end

lib/liquid/profiler/hooks.rb

@@ -1,25 +1,35 @@
 # frozen_string_literal: true
 
 module Liquid
-  class BlockBody
-    def render_node_with_profiling(context, output, node)
-      Profiler.profile_node_render(node) do
-        render_node_without_profiling(context, output, node)
+  module BlockBodyProfilingHook
+    def render_node(context, output, node)
+      if (profiler = context.profiler)
+        profiler.profile_node(context.template_name, code: node.raw, line_number: node.line_number) do
+          super
+        end
+      else
+        super
       end
     end
-
-    alias_method :render_node_without_profiling, :render_node
-    alias_method :render_node, :render_node_with_profiling
   end
+  BlockBody.prepend(BlockBodyProfilingHook)
 
-  class Include < Tag
-    def render_to_output_buffer_with_profiling(context, output)
-      Profiler.profile_children(context.evaluate(@template_name_expr).to_s) do
-        render_to_output_buffer_without_profiling(context, output)
-      end
+  module DocumentProfilingHook
+    def render_to_output_buffer(context, output)
+      return super unless context.profiler
+      context.profiler.profile(context.template_name) { super }
     end
-
-    alias_method :render_to_output_buffer_without_profiling, :render_to_output_buffer
-    alias_method :render_to_output_buffer, :render_to_output_buffer_with_profiling
   end
+  Document.prepend(DocumentProfilingHook)
+
+  module ContextProfilingHook
+    attr_accessor :profiler
+
+    def new_isolated_subcontext
+      new_context = super
+      new_context.profiler = profiler
+      new_context
+    end
+  end
+  Context.prepend(ContextProfilingHook)
 end

lib/liquid/range_lookup.rb

@@ -4,7 +4,7 @@ module Liquid
   class RangeLookup
     def self.parse(start_markup, end_markup)
       start_obj = Expression.parse(start_markup)
-      end_obj = Expression.parse(end_markup)
+      end_obj   = Expression.parse(end_markup)
       if start_obj.respond_to?(:evaluate) || end_obj.respond_to?(:evaluate)
         new(start_obj, end_obj)
       else
@@ -12,17 +12,23 @@ module Liquid
       end
     end
 
+    attr_reader :start_obj, :end_obj
+
     def initialize(start_obj, end_obj)
       @start_obj = start_obj
-      @end_obj = end_obj
+      @end_obj   = end_obj
     end
 
     def evaluate(context)
       start_int = to_integer(context.evaluate(@start_obj))
-      end_int = to_integer(context.evaluate(@end_obj))
+      end_int   = to_integer(context.evaluate(@end_obj))
       start_int..end_int
     end
 
+    def compile_expr(compiler)
+      compiler.fallback_evaluate_expr(self)
+    end
+
     private
 
     def to_integer(input)
@@ -35,5 +41,11 @@ module Liquid
         Utils.to_integer(input)
       end
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.start_obj, @node.end_obj]
+      end
+    end
   end
 end

lib/liquid/registers/disabled_tags.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-module Liquid
-  class DisabledTags < Register
-    def initialize
-      @disabled_tags = {}
-    end
-
-    def disabled?(tag)
-      @disabled_tags.key?(tag) && @disabled_tags[tag] > 0
-    end
-
-    def disable(tags)
-      tags.each(&method(:increment))
-      yield
-    ensure
-      tags.each(&method(:decrement))
-    end
-
-    private
-
-    def increment(tag)
-      @disabled_tags[tag] ||= 0
-      @disabled_tags[tag] += 1
-    end
-
-    def decrement(tag)
-      @disabled_tags[tag] -= 1
-    end
-  end
-
-  Template.add_register(:disabled_tags, DisabledTags.new)
-end

lib/liquid/resource_limits.rb

@@ -2,24 +2,61 @@
 
 module Liquid
   class ResourceLimits
-    attr_accessor :render_length, :render_score, :assign_score,
-      :render_length_limit, :render_score_limit, :assign_score_limit
+    attr_accessor :render_length_limit, :render_score_limit, :assign_score_limit
+    attr_reader :render_score, :assign_score
 
     def initialize(limits)
       @render_length_limit = limits[:render_length_limit]
-      @render_score_limit = limits[:render_score_limit]
-      @assign_score_limit = limits[:assign_score_limit]
+      @render_score_limit  = limits[:render_score_limit]
+      @assign_score_limit  = limits[:assign_score_limit]
       reset
     end
 
+    def increment_render_score(amount)
+      @render_score += amount
+      raise_limits_reached if @render_score_limit && @render_score > @render_score_limit
+    end
+
+    def increment_assign_score(amount)
+      @assign_score += amount
+      raise_limits_reached if @assign_score_limit && @assign_score > @assign_score_limit
+    end
+
+    # update either render_length or assign_score based on whether or not the writes are captured
+    def increment_write_score(output)
+      if (last_captured = @last_capture_length)
+        captured = output.bytesize
+        increment = captured - last_captured
+        @last_capture_length = captured
+        increment_assign_score(increment)
+      elsif @render_length_limit && output.bytesize > @render_length_limit
+        raise_limits_reached
+      end
+    end
+
+    def raise_limits_reached
+      @reached_limit = true
+      raise MemoryError, "Memory limits exceeded"
+    end
+
     def reached?
-      (@render_length_limit && @render_length > @render_length_limit) ||
-        (@render_score_limit && @render_score > @render_score_limit) ||
-        (@assign_score_limit && @assign_score > @assign_score_limit)
+      @reached_limit
     end
 
     def reset
-      @render_length = @render_score = @assign_score = 0
+      @reached_limit = false
+      @last_capture_length = nil
+      @render_score = @assign_score = 0
+    end
+
+    def with_capture
+      old_capture_length = @last_capture_length
+      begin
+        @last_capture_length = 0
+        yield
+      ensure
+        @last_capture_length = old_capture_length
+      end
     end
   end
 end

lib/liquid/standardfilters.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
 
 require 'cgi'
+require 'base64'
 require 'bigdecimal'
 
 module Liquid
   module StandardFilters
+    MAX_INT = (1 << 31) - 1
     HTML_ESCAPE = {
       '&' => '&amp;',
       '>' => '&gt;',
@@ -13,7 +15,7 @@ module Liquid
       "'" => '&#39;',
     }.freeze
     HTML_ESCAPE_ONCE_REGEXP = /["><']|&(?!([a-zA-Z]+|(#\d+));)/
-    STRIP_HTML_BLOCKS = Regexp.union(
+    STRIP_HTML_BLOCKS       = Regexp.union(
       %r{<script.*?</script>}m,
       /<!--.*?-->/m,
       %r{<style.*?</style>}m
@@ -41,7 +43,7 @@ module Liquid
     end
 
     def escape(input)
-      CGI.escapeHTML(input.to_s).untaint unless input.nil?
+      CGI.escapeHTML(input.to_s) unless input.nil?
     end
     alias_method :h, :escape
 
@@ -62,6 +64,26 @@ module Liquid
       result
     end
 
+    def base64_encode(input)
+      Base64.strict_encode64(input.to_s)
+    end
+
+    def base64_decode(input)
+      Base64.strict_decode64(input.to_s)
+    rescue ::ArgumentError
+      raise Liquid::ArgumentError, "invalid base64 provided to base64_decode"
+    end
+
+    def base64_url_safe_encode(input)
+      Base64.urlsafe_encode64(input.to_s)
+    end
+
+    def base64_url_safe_decode(input)
+      Base64.urlsafe_decode64(input.to_s)
+    rescue ::ArgumentError
+      raise Liquid::ArgumentError, "invalid base64 provided to base64_url_safe_decode"
+    end
+
     def slice(input, offset, length = nil)
       offset = Utils.to_integer(offset)
       length = length ? Utils.to_integer(length) : 1
@@ -77,20 +99,33 @@ module Liquid
     def truncate(input, length = 50, truncate_string = "...")
       return if input.nil?
       input_str = input.to_s
-      length = Utils.to_integer(length)
+      length    = Utils.to_integer(length)
+
       truncate_string_str = truncate_string.to_s
+
       l = length - truncate_string_str.length
       l = 0 if l < 0
+
       input_str.length > length ? input_str[0...l].concat(truncate_string_str) : input_str
     end
 
     def truncatewords(input, words = 15, truncate_string = "...")
       return if input.nil?
-      wordlist = input.to_s.split
+      input = input.to_s
       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
+      words = 1 if words <= 0
+
+      wordlist = begin
+        input.split(" ", words + 1)
+      rescue RangeError
+        raise if words + 1 < MAX_INT
+        # e.g. integer #{words} too big to convert to `int'
+        raise Liquid::ArgumentError, "integer #{words} too big for truncatewords"
+      end
+      return input if wordlist.length <= words
+
+      wordlist.pop
+      wordlist.join(" ").concat(truncate_string.to_s)
     end
 
     # Split input string into an array of substrings separated by given pattern.
@@ -115,7 +150,7 @@ module Liquid
     end
 
     def strip_html(input)
-      empty = ''
+      empty  = ''
       result = input.to_s.gsub(STRIP_HTML_BLOCKS, empty)
       result.gsub!(STRIP_HTML_TAGS, empty)
       result
@@ -128,13 +163,13 @@ module Liquid
 
     # Join elements of the array with certain character between them
     def join(input, glue = ' ')
-      InputIterator.new(input).join(glue)
+      InputIterator.new(input, context).join(glue)
     end
 
     # Sort elements of the array
     # provide optional property with which to sort an array of hashes or drops
     def sort(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       return [] if ary.empty?
 
@@ -154,7 +189,7 @@ module Liquid
     # Sort elements of an array ignoring case if strings
     # provide optional property with which to sort an array of hashes or drops
     def sort_natural(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       return [] if ary.empty?
 
@@ -174,21 +209,27 @@ module Liquid
     # Filter the elements of an array to those with a certain property value.
     # By default the target is any truthy value.
     def where(input, property, target_value = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       if ary.empty?
         []
-      elsif ary.first.respond_to?(:[]) && target_value.nil?
-        begin
-          ary.select { |item| item[property] }
+      elsif target_value.nil?
+        ary.select do |item|
+          item[property]
         rescue TypeError
           raise_property_error(property)
+        rescue NoMethodError
+          return nil unless item.respond_to?(:[])
+          raise
         end
-      elsif ary.first.respond_to?(:[])
-        begin
-          ary.select { |item| item[property] == target_value }
+      else
+        ary.select do |item|
+          item[property] == target_value
         rescue TypeError
           raise_property_error(property)
+        rescue NoMethodError
+          return nil unless item.respond_to?(:[])
+          raise
         end
       end
     end
@@ -196,30 +237,33 @@ module Liquid
     # Remove duplicate elements from an array
     # provide optional property with which to determine uniqueness
     def uniq(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       if property.nil?
         ary.uniq
       elsif ary.empty? # The next two cases assume a non-empty array.
         []
-      elsif ary.first.respond_to?(:[])
-        begin
-          ary.uniq { |a| a[property] }
+      else
+        ary.uniq do |item|
+          item[property]
         rescue TypeError
           raise_property_error(property)
+        rescue NoMethodError
+          return nil unless item.respond_to?(:[])
+          raise
         end
       end
     end
 
     # Reverse the elements of an array
     def reverse(input)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
       ary.reverse
     end
 
     # map/collect on a given property
     def map(input, property)
-      InputIterator.new(input).map do |e|
+      InputIterator.new(input, context).map do |e|
         e = e.call if e.is_a?(Proc)
 
         if property == "to_liquid"
@@ -236,17 +280,20 @@ module Liquid
     # Remove nils within an array
     # provide optional property with which to check for nil
     def compact(input, property = nil)
-      ary = InputIterator.new(input)
+      ary = InputIterator.new(input, context)
 
       if property.nil?
         ary.compact
       elsif ary.empty? # The next two cases assume a non-empty array.
         []
-      elsif ary.first.respond_to?(:[])
-        begin
-          ary.reject { |a| a[property].nil? }
+      else
+        ary.reject do |item|
+          item[property].nil?
         rescue TypeError
           raise_property_error(property)
+        rescue NoMethodError
+          return nil unless item.respond_to?(:[])
+          raise
         end
       end
     end
@@ -261,14 +308,34 @@ module Liquid
       input.to_s.sub(string.to_s, replacement.to_s)
     end
 
+    # Replace the last occurrences of a string with another
+    def replace_last(input, string, replacement)
+      input = input.to_s
+      string = string.to_s
+      replacement = replacement.to_s
+
+      start_index = input.rindex(string)
+
+      return input unless start_index
+
+      output = input.dup
+      output[start_index, string.length] = replacement
+      output
+    end
+
     # remove a substring
     def remove(input, string)
-      input.to_s.gsub(string.to_s, '')
+      replace(input, string, '')
     end
 
     # remove the first occurrences of a substring
     def remove_first(input, string)
-      input.to_s.sub(string.to_s, '')
+      replace_first(input, string, '')
+    end
+
+    # remove the last occurences of a substring
+    def remove_last(input, string)
+      replace_last(input, string, '')
     end
 
     # add one string to another
@@ -280,7 +347,7 @@ module Liquid
       unless array.respond_to?(:to_ary)
         raise ArgumentError, "concat filter requires an array argument"
       end
-      InputIterator.new(input).concat(array)
+      InputIterator.new(input, context).concat(array)
     end
 
     # prepend a string to another
@@ -290,7 +357,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(/\r?\n/, "<br />\n")
     end
 
     # Reformat a date using Ruby's core Time#strftime( string ) -> string
@@ -421,17 +488,26 @@ module Liquid
       result.is_a?(BigDecimal) ? result.to_f : result
     end
 
-    def default(input, default_value = '')
-      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
-      end
+    # Set a default value when the input is nil, false or empty
+    #
+    # Example:
+    #    {{ product.title | default: "No Title" }}
+    #
+    # Use `allow_false` when an input should only be tested against nil or empty and not false.
+    #
+    # Example:
+    #    {{ product.title | default: "No Title", allow_false: true }}
+    #
+    def default(input, default_value = '', options = {})
+      options = {} unless options.is_a?(Hash)
+      false_check = options['allow_false'] ? input.nil? : !Liquid::Utils.to_liquid_value(input)
+      false_check || (input.respond_to?(:empty?) && input.empty?) ? default_value : input
     end
 
     private
 
+    attr_reader :context
+
     def raise_property_error(property)
       raise Liquid::ArgumentError, "cannot select the property '#{property}'"
     end
@@ -442,10 +518,16 @@ module Liquid
     end
 
     def nil_safe_compare(a, b)
-      if !a.nil? && !b.nil?
-        a <=> b
+      result = a <=> b
+
+      if result
+        result
+      elsif a.nil?
+        1
+      elsif b.nil?
+        -1
       else
-        a.nil? ? 1 : -1
+        raise Liquid::ArgumentError, "cannot sort values of incompatible types"
       end
     end
 
@@ -460,8 +542,9 @@ module Liquid
     class InputIterator
       include Enumerable
 
-      def initialize(input)
-        @input = if input.is_a?(Array)
+      def initialize(input, context)
+        @context = context
+        @input   = if input.is_a?(Array)
           input.flatten
         elsif input.is_a?(Hash)
           [input]
@@ -499,7 +582,9 @@ module Liquid
 
       def each
         @input.each do |e|
-          yield(e.respond_to?(:to_liquid) ? e.to_liquid : e)
+          e = e.respond_to?(:to_liquid) ? e.to_liquid : e
+          e.context = @context if e.respond_to?(:context=)
+          yield(e)
         end
       end
     end

lib/liquid/static_registers.rb

@@ -2,10 +2,10 @@
 
 module Liquid
   class StaticRegisters
-    attr_reader :static, :registers
+    attr_reader :static
 
     def initialize(registers = {})
-      @static = registers.is_a?(StaticRegisters) ? registers.static : registers
+      @static    = registers.is_a?(StaticRegisters) ? registers.static : registers
       @registers = {}
     end
 
@@ -25,8 +25,20 @@ module Liquid
       @registers.delete(key)
     end
 
-    def fetch(key, default = nil)
-      key?(key) ? self[key] : default
+    UNDEFINED = Object.new
+
+    def fetch(key, default = UNDEFINED, &block)
+      if @registers.key?(key)
+        @registers.fetch(key)
+      elsif default != UNDEFINED
+        if block_given?
+          @static.fetch(key, &block)
+        else
+          @static.fetch(key, default)
+        end
+      else
+        @static.fetch(key, &block)
+      end
     end
 
     def key?(key)

lib/liquid/strainer.rb

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

lib/liquid/strainer_factory.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Liquid
+  # StrainerFactory is the factory for the filters system.
+  module StrainerFactory
+    extend self
+
+    def add_global_filter(filter)
+      strainer_class_cache.clear
+      GlobalCache.add_filter(filter)
+    end
+
+    def create(context, filters = [])
+      strainer_from_cache(filters).new(context)
+    end
+
+    GlobalCache = Class.new(StrainerTemplate)
+
+    private
+
+    def strainer_from_cache(filters)
+      if filters.empty?
+        GlobalCache
+      else
+        strainer_class_cache[filters] ||= begin
+          klass = Class.new(GlobalCache)
+          filters.each { |f| klass.add_filter(f) }
+          klass
+        end
+      end
+    end
+
+    def strainer_class_cache
+      @strainer_class_cache ||= {}
+    end
+  end
+end

lib/liquid/strainer_template.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Liquid
+  # StrainerTemplate is the computed class for the filters system.
+  # New filters are mixed into the strainer class which is then instantiated for each liquid template render run.
+  #
+  # The Strainer only allows method calls defined in filters given to it via StrainerFactory.add_global_filter,
+  # Context#add_filters or Template.register_filter
+  class StrainerTemplate
+    def initialize(context)
+      @context = context
+    end
+
+    class << self
+      def add_filter(filter)
+        return if include?(filter)
+
+        invokable_non_public_methods = (filter.private_instance_methods + filter.protected_instance_methods).select { |m| invokable?(m) }
+        if invokable_non_public_methods.any?
+          raise MethodOverrideError, "Filter overrides registered public methods as non public: #{invokable_non_public_methods.join(', ')}"
+        end
+
+        include(filter)
+
+        filter_methods.merge(filter.public_instance_methods.map(&:to_s))
+      end
+
+      def invokable?(method)
+        filter_methods.include?(method.to_s)
+      end
+
+      def inherited(subclass)
+        super
+        subclass.instance_variable_set(:@filter_methods, @filter_methods.dup)
+      end
+
+      private
+
+      def filter_methods
+        @filter_methods ||= Set.new
+      end
+    end
+
+    def invoke(method, *args)
+      if self.class.invokable?(method)
+        send(method, *args)
+      elsif @context.strict_filters
+        raise Liquid::UndefinedFilter, "undefined filter #{method}"
+      else
+        args.first
+      end
+    rescue ::ArgumentError => e
+      raise Liquid::ArgumentError, e.message, e.backtrace
+    end
+  end
+end

lib/liquid/tablerowloop_drop.rb

@@ -4,10 +4,10 @@ module Liquid
   class TablerowloopDrop < Drop
     def initialize(length, cols)
       @length = length
-      @row = 1
-      @col = 1
-      @cols = cols
-      @index = 0
+      @row    = 1
+      @col    = 1
+      @cols   = cols
+      @index  = 0
     end
 
     attr_reader :length, :col, :row

lib/liquid/tag.rb

@@ -13,22 +13,20 @@ module Liquid
         tag
       end
 
-      def disable_tags(*tags)
-        disabled_tags.push(*tags)
+      def disable_tags(*tag_names)
+        @disabled_tags ||= []
+        @disabled_tags.concat(tag_names)
+        prepend(Disabler)
       end
 
       private :new
-
-      def disabled_tags
-        @disabled_tags ||= []
-      end
     end
 
     def initialize(tag_name, markup, parse_context)
-      @tag_name   = tag_name
-      @markup     = markup
+      @tag_name      = tag_name
+      @markup        = markup
       @parse_context = parse_context
-      @line_number = parse_context.line_number
+      @line_number   = parse_context.line_number
     end
 
     def parse(_tokens)
@@ -46,14 +44,6 @@ module Liquid
       ''
     end
 
-    def disabled?(context)
-      context.registers[:disabled_tags].disabled?(tag_name)
-    end
-
-    def disabled_error_message
-      "#{tag_name} #{options[:locale].t('errors.disabled.tag')}"
-    end
-
     # For backwards compatibility with custom tags. In a future release, the semantics
     # of the `render_to_output_buffer` method will become the default and the `render`
     # method will be removed.
@@ -66,8 +56,10 @@ module Liquid
       false
     end
 
-    def disabled_tags
-      self.class.disabled_tags
+    private
+
+    def parse_expression(markup)
+      parse_context.parse_expression(markup)
     end
   end
 end

lib/liquid/tag/disableable.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Tag
+    module Disableable
+      def render_to_output_buffer(context, output)
+        if context.tag_disabled?(tag_name)
+          output << disabled_error(context)
+          return
+        end
+        super
+      end
+
+      def disabled_error(context)
+        # raise then rescue the exception so that the Context#exception_renderer can re-raise it
+        raise DisabledError, "#{tag_name} #{parse_context[:locale].t('errors.disabled.tag')}"
+      rescue DisabledError => exc
+        context.handle_error(exc, line_number)
+      end
+    end
+  end
+end

lib/liquid/tag/disabler.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Liquid
+  class Tag
+    module Disabler
+      module ClassMethods
+        attr_reader :disabled_tags
+      end
+
+      def self.prepended(base)
+        base.extend(ClassMethods)
+      end
+
+      def render_to_output_buffer(context, output)
+        context.with_disabled_tags(self.class.disabled_tags) do
+          super
+        end
+      end
+    end
+  end
+end

lib/liquid/tags/assign.rb

@@ -12,26 +12,27 @@ module Liquid
   class Assign < Tag
     Syntax = /(#{VariableSignature}+)\s*=\s*(.*)\s*/om
 
-    def self.syntax_error_translation_key
-      "errors.syntax.assign"
+    # @api private
+    def self.raise_syntax_error(parse_context)
+      raise Liquid::SyntaxError, parse_context.locale.t('errors.syntax.assign')
     end
 
     attr_reader :to, :from
 
-    def initialize(tag_name, markup, options)
+    def initialize(tag_name, markup, parse_context)
       super
       if markup =~ Syntax
-        @to = Regexp.last_match(1)
-        @from = Variable.new(Regexp.last_match(2), options)
+        @to   = Regexp.last_match(1)
+        @from = Variable.new(Regexp.last_match(2), parse_context)
       else
-        raise SyntaxError, options[:locale].t(self.class.syntax_error_translation_key)
+        self.class.raise_syntax_error(parse_context)
       end
     end
 
     def render_to_output_buffer(context, output)
       val = @from.render(context)
       context.scopes.last[@to] = val
-      context.resource_limits.assign_score += assign_score_of(val)
+      context.resource_limits.increment_assign_score(assign_score_of(val))
       output
     end
 
@@ -44,11 +45,18 @@ module Liquid
     def assign_score_of(val)
       if val.instance_of?(String)
         val.bytesize
-      elsif val.instance_of?(Array) || val.instance_of?(Hash)
+      elsif val.instance_of?(Array)
         sum = 1
         # Uses #each to avoid extra allocations.
         val.each { |child| sum += assign_score_of(child) }
         sum
+      elsif val.instance_of?(Hash)
+        sum = 1
+        val.each do |key, entry_value|
+          sum += assign_score_of(key)
+          sum += assign_score_of(entry_value)
+        end
+        sum
       else
         1
       end

lib/liquid/tags/break.rb

@@ -11,8 +11,11 @@ module Liquid
   #    {% endfor %}
   #
   class Break < Tag
-    def interrupt
-      BreakInterrupt.new
+    INTERRUPT = BreakInterrupt.new.freeze
+
+    def render_to_output_buffer(context, output)
+      context.push_interrupt(INTERRUPT)
+      output
     end
   end
 

lib/liquid/tags/capture.rb

@@ -25,10 +25,10 @@ module Liquid
     end
 
     def render_to_output_buffer(context, output)
-      previous_output_size = output.bytesize
-      super
-      context.scopes.last[@to] = output
-      context.resource_limits.assign_score += (output.bytesize - previous_output_size)
+      context.resource_limits.with_capture do
+        capture_output = render(context)
+        context.scopes.last[@to] = capture_output
+      end
       output
     end
 

lib/liquid/tags/case.rb

@@ -12,15 +12,23 @@ module Liquid
       @blocks = []
 
       if markup =~ Syntax
-        @left = Expression.parse(Regexp.last_match(1))
+        @left = parse_expression(Regexp.last_match(1))
       else
         raise SyntaxError, options[:locale].t("errors.syntax.case")
       end
     end
 
     def parse(tokens)
-      body = BlockBody.new
+      body = case_body = new_body
       body = @blocks.last.attachment while parse_body(body, tokens)
+      @blocks.reverse_each do |condition|
+        body = condition.attachment
+        unless body.frozen?
+          body.remove_blank_strings if blank?
+          body.freeze
+        end
+      end
+      case_body.freeze
     end
 
     def nodelist
@@ -44,7 +52,14 @@ module Liquid
       @blocks.each do |block|
         if block.else?
           block.attachment.render_to_output_buffer(context, output) if execute_else_block
-        elsif block.evaluate(context)
+          next
+        end
+
+        result = Liquid::Utils.to_liquid_value(
+          block.evaluate(context)
+        )
+
+        if result
           execute_else_block = false
           block.attachment.render_to_output_buffer(context, output)
         end
@@ -56,7 +71,7 @@ module Liquid
     private
 
     def record_when_condition(markup)
-      body = BlockBody.new
+      body = new_body
 
       while markup
         unless markup =~ WhenSyntax
@@ -65,7 +80,7 @@ module Liquid
 
         markup = Regexp.last_match(2)
 
-        block = Condition.new(@left, '==', Expression.parse(Regexp.last_match(1)))
+        block = Condition.new(@left, '==', Condition.parse_expression(parse_context, Regexp.last_match(1)))
         block.attach(body)
         @blocks << block
       end
@@ -77,7 +92,7 @@ module Liquid
       end
 
       block = ElseCondition.new
-      block.attach(BlockBody.new)
+      block.attach(new_body)
       @blocks << block
     end
 

lib/liquid/tags/continue.rb

@@ -11,8 +11,11 @@ module Liquid
   #    {% endfor %}
   #
   class Continue < Tag
-    def interrupt
-      ContinueInterrupt.new
+    INTERRUPT = ContinueInterrupt.new.freeze
+
+    def render_to_output_buffer(context, output)
+      context.push_interrupt(INTERRUPT)
+      output
     end
   end
 

lib/liquid/tags/cycle.rb

@@ -24,10 +24,10 @@ module Liquid
       case markup
       when NamedSyntax
         @variables = variables_from_string(Regexp.last_match(2))
-        @name = Expression.parse(Regexp.last_match(1))
+        @name      = parse_expression(Regexp.last_match(1))
       when SimpleSyntax
         @variables = variables_from_string(markup)
-        @name = @variables.to_s
+        @name      = @variables.to_s
       else
         raise SyntaxError, options[:locale].t("errors.syntax.cycle")
       end
@@ -36,7 +36,7 @@ module Liquid
     def render_to_output_buffer(context, output)
       context.registers[:cycle] ||= {}
 
-      key = context.evaluate(@name)
+      key       = context.evaluate(@name)
       iteration = context.registers[:cycle][key].to_i
 
       val = context.evaluate(@variables[iteration])
@@ -50,9 +50,9 @@ module Liquid
       output << val
 
       iteration += 1
-      iteration  = 0 if iteration >= @variables.size
-      context.registers[:cycle][key] = iteration
+      iteration = 0 if iteration >= @variables.size
 
+      context.registers[:cycle][key] = iteration
       output
     end
 
@@ -61,7 +61,7 @@ module Liquid
     def variables_from_string(markup)
       markup.split(',').collect do |var|
         var =~ /\s*(#{QuotedFragment})\s*/o
-        Regexp.last_match(1) ? Expression.parse(Regexp.last_match(1)) : nil
+        Regexp.last_match(1) ? parse_expression(Regexp.last_match(1)) : nil
       end.compact
     end
 

lib/liquid/tags/echo.rb

@@ -12,6 +12,8 @@ module Liquid
   #   {% echo user | link %}
   #
   class Echo < Tag
+    attr_reader :variable
+
     def initialize(tag_name, markup, parse_context)
       super
       @variable = Variable.new(markup, parse_context)
@@ -20,6 +22,12 @@ module Liquid
     def render(context)
       @variable.render_to_output_buffer(context, +'')
     end
+
+    class ParseTreeVisitor < Liquid::ParseTreeVisitor
+      def children
+        [@node.variable]
+      end
+    end
   end
 
   Template.register_tag('echo', Echo)

lib/liquid/tags/for.rb

@@ -54,13 +54,20 @@ module Liquid
       super
       @from = @limit = nil
       parse_with_selected_parser(markup)
-      @for_block = BlockBody.new
+      @for_block = new_body
       @else_block = nil
     end
 
     def parse(tokens)
-      return unless parse_body(@for_block, tokens)
-      parse_body(@else_block, tokens)
+      if parse_body(@for_block, tokens)
+        parse_body(@else_block, tokens)
+      end
+      if blank?
+        @else_block&.remove_blank_strings
+        @for_block.remove_blank_strings
+      end
+      @else_block&.freeze
+      @for_block.freeze
     end
 
     def nodelist
@@ -69,7 +76,7 @@ module Liquid
 
     def unknown_tag(tag, markup, tokens)
       return super unless tag == 'else'
-      @else_block = BlockBody.new
+      @else_block = new_body
     end
 
     def render_to_output_buffer(context, output)
@@ -88,11 +95,11 @@ module Liquid
 
     def lax_parse(markup)
       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)
+        @variable_name   = Regexp.last_match(1)
+        collection_name  = Regexp.last_match(2)
+        @reversed        = !!Regexp.last_match(3)
+        @name            = "#{@variable_name}-#{collection_name}"
+        @collection_name = parse_expression(collection_name)
         markup.scan(TagAttributes) do |key, value|
           set_attribute(key, value)
         end
@@ -105,9 +112,11 @@ module Liquid
       p = Parser.new(markup)
       @variable_name = p.consume(:id)
       raise SyntaxError, options[:locale].t("errors.syntax.for_invalid_in") unless p.id?('in')
-      collection_name = p.expression
-      @name = "#{@variable_name}-#{collection_name}"
-      @collection_name = Expression.parse(collection_name)
+
+      collection_name  = p.expression
+      @collection_name = parse_expression(collection_name)
+
+      @name     = "#{@variable_name}-#{collection_name}"
       @reversed = p.id?('reversed')
 
       while p.look(:id) && p.look(:colon, 1)
@@ -156,7 +165,7 @@ module Liquid
 
     def render_segment(context, output, segment)
       for_stack = context.registers[:for_stack] ||= []
-      length = segment.length
+      length    = segment.length
 
       context.stack do
         loop_vars = Liquid::ForloopDrop.new(@name, length, for_stack[-1])
@@ -189,12 +198,13 @@ module Liquid
       case key
       when 'offset'
         @from = if expr == 'continue'
+          Usage.increment('for_offset_continue')
           :continue
         else
-          Expression.parse(expr)
+          parse_expression(expr)
         end
       when 'limit'
-        @limit = Expression.parse(expr)
+        @limit = parse_expression(expr)
       end
     end
 

lib/liquid/tags/if.rb

@@ -12,9 +12,9 @@ module Liquid
   #    There are {% if count < 5 %} less {% else %} more {% endif %} items than you need.
   #
   class If < Block
-    Syntax = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
+    Syntax                  = /(#{QuotedFragment})\s*([=!<>a-z_]+)?\s*(#{QuotedFragment})?/o
     ExpressionsAndOperators = /(?:\b(?:\s?and\s?|\s?or\s?)\b|(?:\s*(?!\b(?:\s?and\s?|\s?or\s?)\b)(?:#{QuotedFragment}|\S+)\s*)+)/o
-    BOOLEAN_OPERATORS = %w(and or).freeze
+    BOOLEAN_OPERATORS       = %w(and or).freeze
 
     attr_reader :blocks
 
@@ -31,10 +31,17 @@ module Liquid
     def parse(tokens)
       while parse_body(@blocks.last.attachment, tokens)
       end
+      @blocks.reverse_each do |block|
+        block.attachment.remove_blank_strings if blank?
+        block.attachment.freeze
+      end
     end
 
+    ELSE_TAG_NAMES = ['elsif', 'else'].freeze
+    private_constant :ELSE_TAG_NAMES
+
     def unknown_tag(tag, markup, tokens)
-      if ['elsif', 'else'].include?(tag)
+      if ELSE_TAG_NAMES.include?(tag)
         push_block(tag, markup)
       else
         super
@@ -43,7 +50,11 @@ module Liquid
 
     def render_to_output_buffer(context, output)
       @blocks.each do |block|
-        if block.evaluate(context)
+        result = Liquid::Utils.to_liquid_value(
+          block.evaluate(context)
+        )
+
+        if result
           return block.attachment.render_to_output_buffer(context, output)
         end
       end
@@ -61,21 +72,25 @@ module Liquid
       end
 
       @blocks.push(block)
-      block.attach(BlockBody.new)
+      block.attach(new_body)
+    end
+
+    def parse_expression(markup)
+      Condition.parse_expression(parse_context, markup)
     end
 
     def lax_parse(markup)
       expressions = markup.scan(ExpressionsAndOperators)
       raise SyntaxError, options[:locale].t("errors.syntax.if") unless expressions.pop =~ Syntax
 
-      condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+      condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(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
 
-        new_condition = Condition.new(Expression.parse(Regexp.last_match(1)), Regexp.last_match(2), Expression.parse(Regexp.last_match(3)))
+        new_condition = Condition.new(parse_expression(Regexp.last_match(1)), Regexp.last_match(2), parse_expression(Regexp.last_match(3)))
         raise SyntaxError, options[:locale].t("errors.syntax.if") unless BOOLEAN_OPERATORS.include?(operator)
         new_condition.send(operator, condition)
         condition = new_condition
@@ -103,9 +118,9 @@ module Liquid
     end
 
     def parse_comparison(p)
-      a = Expression.parse(p.expression)
+      a = parse_expression(p.expression)
       if (op = p.consume?(:comparison))
-        b = Expression.parse(p.expression)
+        b = parse_expression(p.expression)
         Condition.new(a, op, b)
       else
         Condition.new(a)

lib/liquid/tags/include.rb

@@ -16,6 +16,8 @@ module Liquid
   #   {% include 'product' for products %}
   #
   class Include < Tag
+    prepend Tag::Disableable
+
     SYNTAX = /(#{QuotedFragment}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
     Syntax = SYNTAX
 
@@ -29,13 +31,13 @@ module Liquid
         template_name = Regexp.last_match(1)
         variable_name = Regexp.last_match(3)
 
-        @alias_name = Regexp.last_match(5)
-        @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
-        @template_name_expr = Expression.parse(template_name)
-        @attributes = {}
+        @alias_name         = Regexp.last_match(5)
+        @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+        @template_name_expr = parse_expression(template_name)
+        @attributes         = {}
 
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
+          @attributes[key] = parse_expression(value)
         end
 
       else
@@ -65,10 +67,10 @@ module Liquid
       end
 
       old_template_name = context.template_name
-      old_partial = context.partial
+      old_partial       = context.partial
       begin
         context.template_name = template_name
-        context.partial = true
+        context.partial       = true
         context.stack do
           @attributes.each do |key, value|
             context[key] = context.evaluate(value)
@@ -86,7 +88,7 @@ module Liquid
         end
       ensure
         context.template_name = old_template_name
-        context.partial = old_partial
+        context.partial       = old_partial
       end
 
       output

lib/liquid/tags/raw.rb

@@ -14,14 +14,14 @@ module Liquid
     def parse(tokens)
       @body = +''
       while (token = tokens.shift)
-        if token =~ FullTokenPossiblyInvalid
+        if token =~ FullTokenPossiblyInvalid && block_delimiter == Regexp.last_match(2)
           @body << Regexp.last_match(1) if Regexp.last_match(1) != ""
-          return if block_delimiter == Regexp.last_match(2)
+          return
         end
         @body << token unless token.empty?
       end
 
-      raise SyntaxError, parse_context.locale.t("errors.syntax.tag_never_closed", block_name: block_name)
+      raise_tag_never_closed(block_name)
     end
 
     def render_to_output_buffer(_context, output)

lib/liquid/tags/render.rb

@@ -2,7 +2,8 @@
 
 module Liquid
   class Render < Tag
-    SYNTAX = /(#{QuotedString}+)(\s+(?:with|for)\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
+    FOR = 'for'
+    SYNTAX = /(#{QuotedString}+)(\s+(with|#{FOR})\s+(#{QuotedFragment}+))?(\s+(?:as)\s+(#{VariableSegment}+))?/o
 
     disable_tags "include"
 
@@ -14,15 +15,17 @@ module Liquid
       raise SyntaxError, options[:locale].t("errors.syntax.render") unless markup =~ SYNTAX
 
       template_name = Regexp.last_match(1)
-      variable_name = Regexp.last_match(3)
+      with_or_for = Regexp.last_match(3)
+      variable_name = Regexp.last_match(4)
 
-      @alias_name = Regexp.last_match(5)
-      @variable_name_expr = variable_name ? Expression.parse(variable_name) : nil
-      @template_name_expr = Expression.parse(template_name)
+      @alias_name = Regexp.last_match(6)
+      @variable_name_expr = variable_name ? parse_expression(variable_name) : nil
+      @template_name_expr = parse_expression(template_name)
+      @for = (with_or_for == FOR)
 
       @attributes = {}
       markup.scan(TagAttributes) do |key, value|
-        @attributes[key] = Expression.parse(value)
+        @attributes[key] = parse_expression(value)
       end
     end
 
@@ -43,19 +46,27 @@ module Liquid
 
       context_variable_name = @alias_name || template_name.split('/').last
 
-      render_partial_func = ->(var) {
-        inner_context = context.new_isolated_subcontext
+      render_partial_func = ->(var, forloop) {
+        inner_context               = context.new_isolated_subcontext
         inner_context.template_name = template_name
-        inner_context.partial = true
+        inner_context.partial       = true
+        inner_context['forloop']    = forloop if forloop
+
         @attributes.each do |key, value|
           inner_context[key] = context.evaluate(value)
         end
         inner_context[context_variable_name] = var unless var.nil?
         partial.render_to_output_buffer(inner_context, output)
+        forloop&.send(:increment!)
       }
 
       variable = @variable_name_expr ? context.evaluate(@variable_name_expr) : nil
-      variable.is_a?(Array) ? variable.each(&render_partial_func) : render_partial_func.call(variable)
+      if @for && variable.respond_to?(:each) && variable.respond_to?(:count)
+        forloop = Liquid::ForloopDrop.new(template_name, variable.count, nil)
+        variable.each { |var| render_partial_func.call(var, forloop) }
+      else
+        render_partial_func.call(variable, nil)
+      end
 
       output
     end

lib/liquid/tags/table_row.rb

@@ -9,11 +9,11 @@ module Liquid
     def initialize(tag_name, markup, options)
       super
       if markup =~ Syntax
-        @variable_name = Regexp.last_match(1)
-        @collection_name = Expression.parse(Regexp.last_match(2))
-        @attributes = {}
+        @variable_name   = Regexp.last_match(1)
+        @collection_name = parse_expression(Regexp.last_match(2))
+        @attributes      = {}
         markup.scan(TagAttributes) do |key, value|
-          @attributes[key] = Expression.parse(value)
+          @attributes[key] = parse_expression(value)
         end
       else
         raise SyntaxError, options[:locale].t("errors.syntax.table_row")
@@ -24,11 +24,10 @@ module Liquid
       (collection = context.evaluate(@collection_name)) || (return '')
 
       from = @attributes.key?('offset') ? context.evaluate(@attributes['offset']).to_i : 0
-      to = @attributes.key?('limit') ? from + context.evaluate(@attributes['limit']).to_i : nil
+      to   = @attributes.key?('limit')  ? from + context.evaluate(@attributes['limit']).to_i : nil
 
       collection = Utils.slice_collection(collection, from, to)
-
-      length = collection.length
+      length     = collection.length
 
       cols = context.evaluate(@attributes['cols']).to_i
 

lib/liquid/tags/unless.rb

@@ -11,13 +11,21 @@ module Liquid
     def render_to_output_buffer(context, output)
       # First condition is interpreted backwards ( if not )
       first_block = @blocks.first
-      unless first_block.evaluate(context)
+      result = Liquid::Utils.to_liquid_value(
+        first_block.evaluate(context)
+      )
+
+      unless result
         return first_block.attachment.render_to_output_buffer(context, output)
       end
 
       # After the first condition unless works just like if
       @blocks[1..-1].each do |block|
-        if block.evaluate(context)
+        result = Liquid::Utils.to_liquid_value(
+          block.evaluate(context)
+        )
+
+        if result
           return block.attachment.render_to_output_buffer(context, output)
         end
       end

lib/liquid/template.rb

@@ -18,13 +18,11 @@ module Liquid
     attr_accessor :root
     attr_reader :resource_limits, :warnings
 
-    @@file_system = BlankFileSystem.new
-
     class TagRegistry
       include Enumerable
 
       def initialize
-        @tags = {}
+        @tags  = {}
         @cache = {}
       end
 
@@ -63,84 +61,54 @@ module Liquid
       # :lax acts like liquid 2.5 and silently ignores malformed tags in most cases.
       # :warn is the default and will give deprecation warnings when invalid syntax is used.
       # :strict will enforce correct syntax.
-      attr_writer :error_mode
-
-      # Sets how strict the taint checker should be.
-      # :lax is the default, and ignores the taint flag completely
-      # :warn adds a warning, but does not interrupt the rendering
-      # :error raises an error when tainted output is used
-      attr_writer :taint_mode
+      attr_accessor :error_mode
+      Template.error_mode = :lax
 
       attr_accessor :default_exception_renderer
       Template.default_exception_renderer = lambda do |exception|
         exception
       end
 
-      def file_system
-        @@file_system
-      end
+      attr_accessor :file_system
+      Template.file_system = BlankFileSystem.new
 
-      def file_system=(obj)
-        @@file_system = obj
-      end
+      attr_accessor :tags
+      Template.tags = TagRegistry.new
+      private :tags=
 
       def register_tag(name, klass)
         tags[name.to_s] = klass
       end
 
-      def tags
-        @tags ||= TagRegistry.new
-      end
-
-      def add_register(name, klass)
-        registers[name.to_sym] = klass
-      end
-
-      def registers
-        @registers ||= {}
-      end
-
-      def error_mode
-        @error_mode ||= :lax
-      end
-
-      def taint_mode
-        @taint_mode ||= :lax
-      end
-
       # Pass a module with filter methods which should be available
       # to all liquid views. Good for registering the standard library
       def register_filter(mod)
-        Strainer.global_filter(mod)
+        StrainerFactory.add_global_filter(mod)
       end
 
-      def default_resource_limits
-        @default_resource_limits ||= {}
-      end
+      attr_accessor :default_resource_limits
+      Template.default_resource_limits = {}
+      private :default_resource_limits=
 
       # creates a new <tt>Template</tt> object from liquid source code
       # To enable profiling, pass in <tt>profile: true</tt> as an option.
       # See Liquid::Profiler for more information
       def parse(source, options = {})
-        template = Template.new
-        template.parse(source, options)
+        new.parse(source, options)
       end
     end
 
     def initialize
-      @rethrow_errors = false
-      @resource_limits = ResourceLimits.new(self.class.default_resource_limits)
+      @rethrow_errors  = false
+      @resource_limits = ResourceLimits.new(Template.default_resource_limits)
     end
 
     # Parse source code.
     # Returns self for easy chaining
     def parse(source, options = {})
-      @options = options
-      @profiling = options[:profile]
-      @line_numbers = options[:line_numbers] || @profiling
-      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
-      @root = Document.parse(tokenize(source), parse_context)
-      @warnings = parse_context.warnings
+      parse_context = configure_options(options)
+      tokenizer     = parse_context.new_tokenizer(source, start_line_number: @line_numbers && 1)
+      @root         = Document.parse(tokenizer, parse_context)
       self
     end
 
@@ -182,12 +150,12 @@ module Liquid
         c = args.shift
 
         if @rethrow_errors
-          c.exception_renderer = ->(_e) { raise }
+          c.exception_renderer = Liquid::RAISE_EXCEPTION_LAMBDA
         end
 
         c
       when Liquid::Drop
-        drop = args.shift
+        drop         = args.shift
         drop.context = Context.new([drop, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
       when Hash
         Context.new([args.shift, assigns], instance_assigns, registers, @rethrow_errors, @resource_limits)
@@ -204,7 +172,7 @@ module Liquid
       case args.last
       when Hash
         options = args.pop
-        output = options[:output] if options[:output]
+        output  = options[:output] if options[:output]
 
         options[:registers]&.each do |key, register|
           context_register[key] = register
@@ -215,19 +183,16 @@ module Liquid
         context.add_filters(args.pop)
       end
 
-      Template.registers.each do |key, register|
-        context_register[key] = register
-      end
-
       # Retrying a render resets resource usage
       context.resource_limits.reset
 
+      if @profiling && context.profiler.nil?
+        @profiler = context.profiler = Liquid::Profiler.new
+      end
+
       begin
         # render the nodelist.
-        # for performance reasons we get an array back here. join will make a string out of it.
-        with_profiling(context) do
-          @root.render_to_output_buffer(context, output || +'')
-        end
+        @root.render_to_output_buffer(context, output || +'')
       rescue Liquid::MemoryError => e
         context.handle_error(e)
       ensure
@@ -246,33 +211,25 @@ module Liquid
 
     private
 
-    def tokenize(source)
-      Tokenizer.new(source, @line_numbers)
-    end
-
-    def with_profiling(context)
-      if @profiling && !context.partial
+    def configure_options(options)
+      if (profiling = options[:profile])
         raise "Profiler not loaded, require 'liquid/profiler' first" unless defined?(Liquid::Profiler)
-
-        @profiler = Profiler.new
-        @profiler.start
-
-        begin
-          yield
-        ensure
-          @profiler.stop
-        end
-      else
-        yield
       end
+
+      @options      = options
+      @profiling    = profiling
+      @line_numbers = options[:line_numbers] || @profiling
+      parse_context = options.is_a?(ParseContext) ? options : ParseContext.new(options)
+      @warnings     = parse_context.warnings
+      parse_context
     end
 
     def apply_options_to_context(context, options)
       context.add_filters(options[:filters]) if options[:filters]
-      context.global_filter = options[:global_filter] if options[:global_filter]
+      context.global_filter      = options[:global_filter] if options[:global_filter]
       context.exception_renderer = options[:exception_renderer] if options[:exception_renderer]
-      context.strict_variables = options[:strict_variables] if options[:strict_variables]
-      context.strict_filters = options[:strict_filters] if options[:strict_filters]
+      context.strict_variables   = options[:strict_variables] if options[:strict_variables]
+      context.strict_filters     = options[:strict_filters] if options[:strict_filters]
     end
   end
 end

lib/liquid/template_factory.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Liquid
+  class TemplateFactory
+    def for(_template_name)
+      Liquid::Template.new
+    end
+  end
+end

lib/liquid/tokenizer.rb

@@ -5,10 +5,10 @@ module Liquid
     attr_reader :line_number, :for_liquid_tag
 
     def initialize(source, line_numbers = false, line_number: nil, for_liquid_tag: false)
-      @source = source
-      @line_number = line_number || (line_numbers ? 1 : nil)
+      @source         = source.to_s.to_str
+      @line_number    = line_number || (line_numbers ? 1 : nil)
       @for_liquid_tag = for_liquid_tag
-      @tokens = tokenize
+      @tokens         = tokenize
     end
 
     def shift
@@ -24,7 +24,7 @@ module Liquid
     private
 
     def tokenize
-      return [] if @source.to_s.empty?
+      return [] if @source.empty?
 
       return @source.split("\n") if @for_liquid_tag
 

lib/liquid/utils.rb

@@ -12,7 +12,7 @@ module Liquid
 
     def self.slice_collection_using_each(collection, from, to)
       segments = []
-      index = 0
+      index    = 0
 
       # Maintains Ruby 1.8.7 String#each behaviour on 1.9
       if collection.is_a?(String)
@@ -81,5 +81,13 @@ module Liquid
     rescue ::ArgumentError
       nil
     end
+
+    def self.to_liquid_value(obj)
+      # Enable "obj" to represent itself as a primitive value like integer, string, or boolean
+      return obj.to_liquid_value if obj.respond_to?(:to_liquid_value)
+
+      # Otherwise return the object itself
+      obj
+    end
   end
 end

lib/liquid/variable.rb

@@ -12,10 +12,10 @@ module Liquid
   #   {{ user | link }}
   #
   class Variable
-    FilterMarkupRegex = /#{FilterSeparator}\s*(.*)/om
-    FilterParser = /(?:\s+|#{QuotedFragment}|#{ArgumentSeparator})+/o
-    FilterArgsRegex = /(?:#{FilterArgumentSeparator}|#{ArgumentSeparator})\s*((?:\w+\s*\:\s*)?#{QuotedFragment})/o
-    JustTagAttributes = /\A#{TagAttributes}\z/o
+    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
@@ -25,12 +25,12 @@ module Liquid
     include ParserSwitching
 
     def initialize(markup, parse_context)
-      @markup  = markup
-      @name    = nil
+      @markup        = markup
+      @name          = nil
       @parse_context = parse_context
-      @line_number = parse_context.line_number
+      @line_number   = parse_context.line_number
 
-      parse_with_selected_parser(markup)
+      strict_parse_with_error_mode_fallback(markup)
     end
 
     def raw
@@ -45,9 +45,9 @@ module Liquid
       @filters = []
       return unless markup =~ MarkupWithQuotedFragment
 
-      name_markup = Regexp.last_match(1)
+      name_markup   = Regexp.last_match(1)
       filter_markup = Regexp.last_match(2)
-      @name = Expression.parse(name_markup)
+      @name         = Expression.parse(name_markup)
       if filter_markup =~ FilterMarkupRegex
         filters = Regexp.last_match(1).scan(FilterParser)
         filters.each do |f|
@@ -63,6 +63,8 @@ module Liquid
       @filters = []
       p = Parser.new(markup)
 
+      return if p.look(:end_of_string)
+
       @name = Expression.parse(p.expression)
       while p.consume?(:pipe)
         filtername = p.consume(:id)
@@ -81,14 +83,18 @@ module Liquid
     end
 
     def render(context)
-      obj = @filters.inject(context.evaluate(@name)) do |output, (filter_name, filter_args, filter_kwargs)|
+      obj = context.evaluate(@name)
+
+      @filters.each do |filter_name, filter_args, filter_kwargs|
         filter_args = evaluate_filter_expressions(context, filter_args, filter_kwargs)
-        context.invoke(filter_name, output, *filter_args)
+        obj = context.invoke(filter_name, obj, *filter_args)
       end
 
-      obj = context.apply_global_filter(obj)
-      taint_check(context, obj)
-      obj
+      context.apply_global_filter(obj)
+    end
+
+    def compile
+      "__output << #{@name}\n"
     end
 
     def render_to_output_buffer(context, output)
@@ -115,11 +121,11 @@ module Liquid
     private
 
     def parse_filter_expressions(filter_name, unparsed_args)
-      filter_args = []
+      filter_args  = []
       keyword_args = nil
       unparsed_args.each do |a|
         if (matches = a.match(JustTagAttributes))
-          keyword_args ||= {}
+          keyword_args           ||= {}
           keyword_args[matches[1]] = Expression.parse(matches[2])
         else
           filter_args << Expression.parse(a)
@@ -142,25 +148,6 @@ module Liquid
       parsed_args
     end
 
-    def taint_check(context, obj)
-      return unless obj.tainted?
-      return if Template.taint_mode == :lax
-
-      @markup =~ QuotedFragment
-      name = Regexp.last_match(0)
-
-      error = TaintedError.new("variable '#{name}' is tainted and was not escaped")
-      error.line_number = line_number
-      error.template_name = context.template_name
-
-      case Template.taint_mode
-      when :warn
-        context.warnings << error
-      when :error
-        raise error
-      end
-    end
-
     class ParseTreeVisitor < Liquid::ParseTreeVisitor
       def children
         [@node.name] + @node.filters.flatten

lib/liquid/variable_lookup.rb

@@ -2,7 +2,6 @@
 
 module Liquid
   class VariableLookup
-    SQUARE_BRACKETED = /\A\[(.*)\]\z/m
     COMMAND_METHODS = ['size', 'first', 'last'].freeze
 
     attr_reader :name, :lookups
@@ -15,18 +14,18 @@ module Liquid
       lookups = markup.scan(VariableParser)
 
       name = lookups.shift
-      if name =~ SQUARE_BRACKETED
-        name = Expression.parse(Regexp.last_match(1))
+      if name&.start_with?('[') && name&.end_with?(']')
+        name = Expression.parse(name[1..-2])
       end
       @name = name
 
-      @lookups = lookups
+      @lookups       = lookups
       @command_flags = 0
 
       @lookups.each_index do |i|
         lookup = lookups[i]
-        if lookup =~ SQUARE_BRACKETED
-          lookups[i] = Expression.parse(Regexp.last_match(1))
+        if lookup&.start_with?('[') && lookup&.end_with?(']')
+          lookups[i] = Expression.parse(lookup[1..-2])
         elsif COMMAND_METHODS.include?(lookup)
           @command_flags |= 1 << i
         end
@@ -34,12 +33,15 @@ module Liquid
     end
 
     def evaluate(context)
-      name = context.evaluate(@name)
+      name   = context.evaluate(@name)
       object = context.find_variable(name)
 
       @lookups.each_index do |i|
         key = context.evaluate(@lookups[i])
 
+        # Cast "key" to its liquid value to enable it to act as a primitive value
+        key = Liquid::Utils.to_liquid_value(key)
+
         # 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?(:[]) &&
@@ -47,7 +49,7 @@ module Liquid
              (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)
+          res    = context.lookup_and_evaluate(object, key)
           object = res.to_liquid
 
           # Some special cases. If the part wasn't in square brackets and

lib/liquid/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Liquid
-  VERSION = "4.0.3"
+  VERSION = "5.3.0"
 end

liquid.gemspec

@@ -17,9 +17,11 @@ Gem::Specification.new do |s|
   s.license     = "MIT"
   # s.description = "A secure, non-evaling end user template engine with aesthetic markup."
 
-  s.required_ruby_version     = ">= 2.4.0"
+  s.required_ruby_version     = ">= 2.5.0"
   s.required_rubygems_version = ">= 1.3.7"
 
+  s.metadata['allowed_push_host'] = 'https://rubygems.org'
+
   s.test_files  = Dir.glob("{test}/**/*")
   s.files       = Dir.glob("{lib}/**/*") + %w(LICENSE README.md)
 
@@ -27,6 +29,6 @@ Gem::Specification.new do |s|
 
   s.require_path = "lib"
 
-  s.add_development_dependency('rake', '~> 11.3')
+  s.add_development_dependency('rake', '~> 13.0')
   s.add_development_dependency('minitest')
 end

performance/benchmark

@@ -0,0 +1,224 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+unless ENV.key?("BUNDLE_BIN_PATH")
+  exec("bundle", "exec", "ruby",  __FILE__, *ARGV)
+end
+
+require "pry"
+require "liquid"
+require "unicode_plot"
+require "optparse"
+require "open3"
+require "csv"
+require "io/console"
+
+TERM_ROWS, TERM_COLS = IO.console.winsize
+
+def record
+  if ARGV.count != 2
+    STDERR.puts "Usage: benchmark.rb record [output_path]"
+    exit(1)
+  end
+  output_path = ARGV[1]
+  out, status = Open3.capture2("ruby", "#{__dir__}/benchmark_child.rb")
+  File.write(output_path, out)
+end
+
+def calc_stats(nums)
+  mean = nums.reduce(:+) / nums.length
+  variance = nums.map { |n| (n - mean).pow(2) }.reduce(:+) / nums.length
+  stddev = Math.sqrt(variance)
+  {
+    mean: mean,
+    variance: variance,
+    stddev: stddev,
+    normalized: normalize_outliers(mean, stddev, nums),
+    raw: nums
+  }
+end
+
+def normalize_outliers(mean, stddev, nums)
+  cutoff = stddev * 3
+  nums.map do |n|
+    if (n - mean).abs < cutoff
+      n
+    else
+      mean
+    end
+  end
+end
+
+
+def show
+  if ARGV.count < 2
+    STDERR.puts "Usage: benchmark.rb show [path1] [path2]? ..."
+    exit(1)
+  end
+
+  recordings = ARGV.drop(1).to_h do |path|
+    [File.basename(path), CSV.parse(
+      File.open(path),
+      col_sep: "\t",
+      headers: true,
+      converters: :integer
+    )]
+  end
+
+  runs = (1..1000).to_a
+  recordings.values.first.headers.each do |benchmark|
+    colors = [:green, :blue, :red]
+
+    10.times { puts }
+    title = "Benchmark: #{benchmark} (times in µs)"
+    print " " * (TERM_COLS / 2 - title.length)
+    puts title
+    puts
+
+    all_stats = recordings.transform_values do |csv|
+      stats = calc_stats(csv.map { |row| row[benchmark] })
+      stats[:color] = colors.shift
+      stats
+    end
+
+    line_plots = []
+    distributions = []
+    shared_line_plot = nil
+
+    max_mean_stats = all_stats.values.max_by { |stats| stats[:mean] }
+    max_y = (max_mean_stats[:mean] + max_mean_stats[:stddev] * 3).to_i
+
+    all_stats.each do |name, stats|
+      if shared_line_plot == nil
+        shared_line_plot = UnicodePlot.lineplot(
+          runs,
+          stats[:normalized],
+          name: name,
+          width: TERM_COLS - 25,
+          ylim: [0, max_y],
+          color: stats[:color]
+        )
+      else
+        UnicodePlot.lineplot!(shared_line_plot, stats[:normalized], name: name, color: stats[:color])
+      end
+
+      line_plots << render_to_s(UnicodePlot.lineplot(
+        runs,
+        stats[:normalized],
+        name: name,
+        color: stats[:color],
+        width: 40
+      ))
+
+      distributions << render_to_s(UnicodePlot.histogram(
+        stats[:normalized],
+        title: name,
+        color: stats[:color]
+      ))
+    end
+
+    shared_line_plot.render
+    print_columns(line_plots)
+    print_columns(distributions)
+
+    all_times = all_stats.transform_values { |stats| stats[:normalized] }
+    UnicodePlot.boxplot(data: all_times, title: "Comparison", width: TERM_COLS - 25).render
+  end
+end
+
+def render_to_s(plot)
+  io = StringIO.new
+  plot.render(io, color: true)
+  io.string
+end
+
+def visual_length(line)
+  line.gsub(/\e\[(\d+)m/, '').length
+end
+
+def print_columns(cols)
+  col_lines = cols.map { |col| col.split("\n") }
+  col_width = col_lines.map do |lines|
+    lines.map { |line| visual_length(line) }.max
+  end.max
+  col_height = col_lines.map { |lines| lines.length }.max
+
+  (0...col_height).each do |i|
+    col_lines.each do |lines|
+      line = lines[i] || ""
+      vis_length = visual_length(line)
+      print line
+      print(" " * (col_width - vis_length))
+    end
+    puts
+  end
+end
+
+ITERS = 1
+Benchmarks = Class.new do
+  def define(_name, benchmark)
+    @benchmark = benchmark
+  end
+
+  def run
+    start = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+    @benchmark.compile
+    parsed = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+
+    # warmup
+    ITERS.times { @benchmark.render}
+    warm = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+
+    res = nil
+    ITERS.times { res = @benchmark.render }
+    ran = Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+
+    if res.is_a?(String)
+      puts res
+      puts "Output digest: #{Digest::SHA2.hexdigest(res)}"
+    end
+
+    if ENV['SHOW_RUBY'] == '1'
+      STDERR.puts "note: SHOW_RUBY prevents gathering parse metrics"
+      STDERR.puts "render: #{(ran - warm) / ITERS}µs"
+    else
+      STDERR.puts "parse: #{parsed - start}µs"
+      STDERR.puts "render: #{(ran - warm) / ITERS}µs"
+      STDERR.puts "total: #{(ran - warm) / ITERS + (parsed - start)}µs"
+    end
+  end
+end.new
+
+def execute
+  require 'digest'
+
+  if ARGV.count != 2
+    STDERR.puts "Usage: benchmark.rb record [output_path]"
+    exit(1)
+  end
+
+  case ENV['ENGINE']
+  when 'LIQUID_COMPILE'
+    require_relative '../lib/liquid/compile'
+  when 'LIQUID_C'
+    require 'liquid/c'
+  when 'LIQUID_RUBY'
+  else
+    raise "Invalid ENGINE: #{ENV['ENGINE'].inspect}, expected ENGINE=(LIQUID_RUBY|LIQUID_COMPILE)"
+  end
+
+  require_relative "./benchmarks/#{ARGV[1]}.rb"
+  Benchmarks.run
+end
+
+case ARGV.first
+when "record", "r"
+  record
+when "show", "s"
+  show
+when "execute", "x"
+  execute
+else
+  puts "Invalid command. Expected benchmark [record|show|execute] ..."
+  exit 1
+end

performance/benchmark.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'benchmark/ips'
-require_relative 'theme_runner'
-
-Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
-profiler = ThemeRunner.new
-
-Benchmark.ips do |x|
-  x.time = 10
-  x.warmup = 5
-
-  puts
-  puts "Running benchmark for #{x.time} seconds (with #{x.warmup} seconds warmup)."
-  puts
-
-  x.report("parse:") { profiler.compile }
-  x.report("render:") { profiler.render }
-  x.report("parse & render:") { profiler.run }
-end

performance/benchmark_child.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'liquid'
+
+Liquid::Template.error_mode = :strict
+
+case ENV['ENGINE']
+when 'LIQUID_COMPILE'
+  require_relative '../lib/liquid/compile'
+when 'LIQUID_C'
+  require 'liquid/c'
+when 'LIQUID_RUBY'
+else
+  raise "Invalid engine: #{ENV['ENGINE'].inspect}"
+end
+
+OPTIONS = {
+  render_iters: 1000
+}
+
+def get_time_us
+  Process.clock_gettime(Process::CLOCK_MONOTONIC, :microsecond)
+end
+
+Benchmarks = Class.new do
+  def initialize
+    @by_name = {}
+  end
+
+  def define(name, benchmark)
+    @by_name[name] = benchmark
+  end
+
+  def run
+    times = {}
+    @by_name.each do |name, benchmark|
+      benchmark.compile
+
+      times[name] = OPTIONS[:render_iters].times.map do
+        before = get_time_us
+        benchmark.render
+        get_time_us - before
+      end
+    end
+
+    puts times.keys.join("\t")
+    cols = times.values
+    OPTIONS[:render_iters].times do |i|
+      cols.each do |values|
+        print values[i]
+        print "\t" unless values == cols.last
+      end
+      puts
+    end
+  end
+end.new
+
+Dir[__dir__ + "/benchmarks/*.rb", base: __dir__].each do |path|
+  require_relative path
+end
+
+Benchmarks.run

performance/benchmarks/fizzbuzz_10000.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+Benchmarks.define('fizzbuzz_10000', Class.new do
+  TEMPLATE = <<~LIQUID
+  {% for i in (1..#{ENV['COUNT'].to_i}) %}
+    {% liquid
+      assign rem_3 = i | modulo: 3
+      assign rem_5 = i | modulo: 5
+      if rem_3 == 0 and rem_5 == 0
+        echo "Fizzbuzz"
+      elsif rem_3 == 0
+        echo "Fizz"
+      elsif rem_5 == 0
+        echo "Buzz"
+      else
+        echo i
+      endif
+    %}{% endfor %}
+  LIQUID
+
+  def compile
+    @parsed = Liquid::Template.parse(TEMPLATE)
+  end
+
+  def render
+    @parsed.render
+  end
+end.new)

performance/benchmarks/simple_loop.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Benchmarks.define('simple_loop', Class.new do
+  TEMPLATE = "{% for i in (1..1000) %}{{ i }}{% endfor %}"
+
+  def compile
+    @parsed = Liquid::Template.parse(TEMPLATE)
+  end
+
+  def render
+    @parsed.render
+  end
+end.new)

performance/benchmarks/theme_runner.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require_relative '../theme_runner'
+
+#Benchmarks.define('theme_runner', ThemeRunner.new) 

performance/profile.rb

@@ -3,6 +3,16 @@
 require 'stackprof'
 require_relative 'theme_runner'
 
+if ENV['LIQUID_C'] == '1'
+  puts "-- LIQUID C"
+  require 'liquid/c'
+end
+
+if ENV['LIQUID_COMPILE'] == '1'
+  puts "-- COMPILED"
+  require 'liquid/compile'
+end
+
 Liquid::Template.error_mode = ARGV.first.to_sym if ARGV.first
 profiler = ThemeRunner.new
 profiler.run

performance/shopify/comment_form.rb

@@ -8,7 +8,7 @@ class CommentForm < Liquid::Block
 
     if markup =~ Syntax
       @variable_name = Regexp.last_match(1)
-      @attributes = {}
+      @attributes    = {}
     else
       raise SyntaxError, "Syntax Error in 'comment_form' - Valid syntax: comment_form [article]"
     end

performance/shopify/database.rb

@@ -3,11 +3,19 @@
 require 'yaml'
 
 module Database
+  DATABASE_FILE_PATH = "#{__dir__}/vision.database.yml"
+
   # Load the standard vision toolkit database and re-arrage it to be simply exportable
   # to liquid as assigns. All this is based on Shopify
   def self.tables
     @tables ||= begin
-      db = YAML.load_file("#{__dir__}/vision.database.yml")
+      db =
+        if YAML.respond_to?(:unsafe_load_file) # Only Psych 4+ can use unsafe_load_file
+          # unsafe_load_file is needed for YAML references
+          YAML.unsafe_load_file(DATABASE_FILE_PATH)
+        else
+          YAML.load_file(DATABASE_FILE_PATH)
+        end
 
       # From vision source
       db['products'].each do |product|

performance/shopify/liquid.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 $LOAD_PATH.unshift(__dir__ + '/../../lib')
-require_relative '../../lib/liquid'
-
 require_relative 'comment_form'
 require_relative 'paginate'
 require_relative 'json_filter'

performance/shopify/paginate.rb

@@ -8,7 +8,7 @@ class Paginate < Liquid::Block
 
     if markup =~ Syntax
       @collection_name = Regexp.last_match(1)
-      @page_size = if Regexp.last_match(2)
+      @page_size       = if Regexp.last_match(2)
         Regexp.last_match(3).to_i
       else
         20

performance/shopify/shop_filter.rb

@@ -60,7 +60,7 @@ module ShopFilter
 
     case style
     when 'original'
-      return '/files/shops/random_number/' + url
+      '/files/shops/random_number/' + url
     when 'grande', 'large', 'medium', 'compact', 'small', 'thumb', 'icon'
       "/files/shops/random_number/products/#{Regexp.last_match(1)}_#{style}.#{Regexp.last_match(2)}"
     else

performance/theme_runner.rb

@@ -58,9 +58,9 @@ class ThemeRunner
   # `render` is called to benchmark just the render portion of liquid
   def render
     @compiled_tests.each do |test|
-      tmpl = test[:tmpl]
+      tmpl    = test[:tmpl]
       assigns = test[:assigns]
-      layout = test[:layout]
+      layout  = test[:layout]
 
       if layout
         assigns['content_for_layout'] = tmpl.render!(assigns)
@@ -73,10 +73,14 @@ class ThemeRunner
 
   private
 
+  def render_layout(template, layout, assigns)
+    assigns['content_for_layout'] = template.render!(assigns)
+    layout&.render!(assigns)
+  end
+
   def compile_and_render(template, layout, assigns, page_template, template_file)
     compiled_test = compile_test(template, layout, assigns, page_template, template_file)
-    assigns['content_for_layout'] = compiled_test[:tmpl].render!(assigns)
-    compiled_test[:layout].render!(assigns) if layout
+    render_layout(compiled_test[:tmpl], compiled_test[:layout], compiled_test[:assigns])
   end
 
   def compile_all_tests
@@ -88,7 +92,7 @@ class ThemeRunner
   end
 
   def compile_test(template, layout, assigns, page_template, template_file)
-    tmpl = init_template(page_template, template_file)
+    tmpl            = init_template(page_template, template_file)
     parsed_template = tmpl.parse(template).dup
 
     if layout
@@ -113,9 +117,9 @@ class ThemeRunner
 
   # set up a new Liquid::Template object for use in `compile_and_render` and `compile_test`
   def init_template(page_template, template_file)
-    tmpl = Liquid::Template.new
-    tmpl.assigns['page_title'] = 'Page title'
-    tmpl.assigns['template'] = page_template
+    tmpl                         = Liquid::Template.new
+    tmpl.assigns['page_title']   = 'Page title'
+    tmpl.assigns['template']     = page_template
     tmpl.registers[:file_system] = ThemeRunner::FileSystem.new(File.dirname(template_file))
     tmpl
   end

test/integration/assign_test.rb

@@ -10,8 +10,8 @@ class AssignTest < Minitest::Test
     {% assign this-thing = 'Print this-thing' %}
     {{ this-thing }}
     END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
+    template        = Template.parse(template_source)
+    rendered        = template.render!
     assert_equal("Print this-thing", rendered.strip)
   end
 
@@ -44,7 +44,74 @@ class AssignTest < Minitest::Test
       end
     end
     with_error_mode(:lax) do
-      assert Template.parse("{% assign foo = ('X' | downcase) %}")
+      assert(Template.parse("{% assign foo = ('X' | downcase) %}"))
     end
   end
-end # AssignTest
+
+  def test_expression_with_whitespace_in_square_brackets
+    source = "{% assign r = a[ 'b' ] %}{{ r }}"
+    assert_template_result('result', source, 'a' => { 'b' => 'result' })
+  end
+
+  def test_assign_score_exceeding_resource_limit
+    t = Template.parse("{% assign foo = 42 %}{% assign bar = 23 %}")
+    t.resource_limits.assign_score_limit = 1
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
+
+    t.resource_limits.assign_score_limit = 2
+    assert_equal("", t.render!)
+    refute_nil(t.resource_limits.assign_score)
+  end
+
+  def test_assign_score_exceeding_limit_from_composite_object
+    t = Template.parse("{% assign foo = 'aaaa' | reverse %}")
+
+    t.resource_limits.assign_score_limit = 3
+    assert_equal("Liquid error: Memory limits exceeded", t.render)
+    assert(t.resource_limits.reached?)
+
+    t.resource_limits.assign_score_limit = 5
+    assert_equal("", t.render!)
+  end
+
+  def test_assign_score_of_int
+    assert_equal(1, assign_score_of(123))
+  end
+
+  def test_assign_score_of_string_counts_bytes
+    assert_equal(3, assign_score_of('123'))
+    assert_equal(5, assign_score_of('12345'))
+    assert_equal(9, assign_score_of('すごい'))
+  end
+
+  def test_assign_score_of_array
+    assert_equal(1, assign_score_of([]))
+    assert_equal(2, assign_score_of([123]))
+    assert_equal(6, assign_score_of([123, 'abcd']))
+  end
+
+  def test_assign_score_of_hash
+    assert_equal(1, assign_score_of({}))
+    assert_equal(5, assign_score_of('int' => 123))
+    assert_equal(12, assign_score_of('int' => 123, 'str' => 'abcd'))
+  end
+
+  private
+
+  class ObjectWrapperDrop < Liquid::Drop
+    def initialize(obj)
+      @obj = obj
+    end
+
+    def value
+      @obj
+    end
+  end
+
+  def assign_score_of(obj)
+    context = Liquid::Context.new('drop' => ObjectWrapperDrop.new(obj))
+    Liquid::Template.parse('{% assign obj = drop.value %}').render!(context)
+    context.resource_limits.assign_score
+  end
+end

test/integration/block_test.rb

@@ -11,4 +11,48 @@ class BlockTest < Minitest::Test
     end
     assert_equal(exc.message, "Liquid syntax error: 'endunless' is not a valid delimiter for if tags. use endif")
   end
+
+  def test_with_custom_tag
+    with_custom_tag('testtag', Block) do
+      assert(Liquid::Template.parse("{% testtag %} {% endtesttag %}"))
+    end
+  end
+
+  def test_custom_block_tags_have_a_default_render_to_output_buffer_method_for_backwards_compatibility
+    klass1 = Class.new(Block) do
+      def render(*)
+        'hello'
+      end
+    end
+
+    with_custom_tag('blabla', klass1) do
+      template = Liquid::Template.parse("{% blabla %} bla {% endblabla %}")
+
+      assert_equal('hello', template.render)
+
+      buf    = +''
+      output = template.render({}, output: buf)
+      assert_equal('hello', output)
+      assert_equal('hello', buf)
+      assert_equal(buf.object_id, output.object_id)
+    end
+
+    klass2 = Class.new(klass1) do
+      def render(*)
+        'foo' + super + 'bar'
+      end
+    end
+
+    with_custom_tag('blabla', klass2) do
+      template = Liquid::Template.parse("{% blabla %} foo {% endblabla %}")
+
+      assert_equal('foohellobar', template.render)
+
+      buf    = +''
+      output = template.render({}, output: buf)
+      assert_equal('foohellobar', output)
+      assert_equal('foohellobar', buf)
+      assert_equal(buf.object_id, output.object_id)
+    end
+  end
 end

test/integration/capture_test.rb

@@ -14,8 +14,8 @@ class CaptureTest < Minitest::Test
     {% capture this-thing %}Print this-thing{% endcapture %}
     {{ this-thing }}
     END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
+    template        = Template.parse(template_source)
+    rendered        = template.render!
     assert_equal("Print this-thing", rendered.strip)
   end
 
@@ -30,8 +30,8 @@ class CaptureTest < Minitest::Test
     {% endif %}
     {{var}}
     END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
+    template        = Template.parse(template_source)
+    rendered        = template.render!
     assert_equal("test-string", rendered.gsub(/\s/, ''))
   end
 
@@ -45,8 +45,14 @@ class CaptureTest < Minitest::Test
     {% endfor %}
     {{ first }}-{{ second }}
     END_TEMPLATE
-    template = Template.parse(template_source)
-    rendered = template.render!
+    template        = Template.parse(template_source)
+    rendered        = template.render!
     assert_equal("3-3", rendered.gsub(/\s/, ''))
   end
-end # CaptureTest
+
+  def test_increment_assign_score_by_bytes_not_characters
+    t = Template.parse("{% capture foo %}すごい{% endcapture %}")
+    t.render!
+    assert_equal(9, t.resource_limits.assign_score)
+  end
+end

test/integration/context_test.rb

@@ -2,9 +2,595 @@
 
 require 'test_helper'
 
+class HundredCentes
+  def to_liquid
+    100
+  end
+end
+
+class CentsDrop < Liquid::Drop
+  def amount
+    HundredCentes.new
+  end
+
+  def non_zero?
+    true
+  end
+end
+
+class ContextSensitiveDrop < Liquid::Drop
+  def test
+    @context['test']
+  end
+end
+
+class Category
+  attr_accessor :name
+
+  def initialize(name)
+    @name = name
+  end
+
+  def to_liquid
+    CategoryDrop.new(self)
+  end
+end
+
+class CategoryDrop < Liquid::Drop
+  attr_accessor :category, :context
+
+  def initialize(category)
+    @category = category
+  end
+end
+
+class CounterDrop < Liquid::Drop
+  def count
+    @count ||= 0
+    @count  += 1
+  end
+end
+
+class ArrayLike
+  def fetch(index)
+  end
+
+  def [](index)
+    @counts        ||= []
+    @counts[index] ||= 0
+    @counts[index]  += 1
+  end
+
+  def to_liquid
+    self
+  end
+end
+
 class ContextTest < Minitest::Test
   include Liquid
 
+  def setup
+    @context = Liquid::Context.new
+  end
+
+  def test_variables
+    @context['string'] = 'string'
+    assert_equal('string', @context['string'])
+
+    @context['num'] = 5
+    assert_equal(5, @context['num'])
+
+    @context['time'] = Time.parse('2006-06-06 12:00:00')
+    assert_equal(Time.parse('2006-06-06 12:00:00'), @context['time'])
+
+    @context['date'] = Date.today
+    assert_equal(Date.today, @context['date'])
+
+    now = Time.now
+    @context['datetime'] = now
+    assert_equal(now, @context['datetime'])
+
+    @context['bool'] = true
+    assert_equal(true, @context['bool'])
+
+    @context['bool'] = false
+    assert_equal(false, @context['bool'])
+
+    @context['nil'] = nil
+    assert_nil(@context['nil'])
+    assert_nil(@context['nil'])
+  end
+
+  def test_variables_not_existing
+    assert_nil(@context['does_not_exist'])
+  end
+
+  def test_scoping
+    @context.push
+    @context.pop
+
+    assert_raises(Liquid::ContextError) do
+      @context.pop
+    end
+
+    assert_raises(Liquid::ContextError) do
+      @context.push
+      @context.pop
+      @context.pop
+    end
+  end
+
+  def test_length_query
+    @context['numbers'] = [1, 2, 3, 4]
+
+    assert_equal(4, @context['numbers.size'])
+
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4 }
+
+    assert_equal(4, @context['numbers.size'])
+
+    @context['numbers'] = { 1 => 1, 2 => 2, 3 => 3, 4 => 4, 'size' => 1000 }
+
+    assert_equal(1000, @context['numbers.size'])
+  end
+
+  def test_hyphenated_variable
+    @context['oh-my'] = 'godz'
+    assert_equal('godz', @context['oh-my'])
+  end
+
+  def test_add_filter
+    filter = Module.new do
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new
+    context.add_filters(filter)
+    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
+
+    context = Context.new
+    assert_equal('hi?', context.invoke(:hi, 'hi?'))
+
+    context.add_filters(filter)
+    assert_equal('hi? hi!', context.invoke(:hi, 'hi?'))
+  end
+
+  def test_only_intended_filters_make_it_there
+    filter = Module.new do
+      def hi(output)
+        output + ' hi!'
+      end
+    end
+
+    context = Context.new
+    assert_equal("Wookie", context.invoke("hi", "Wookie"))
+
+    context.add_filters(filter)
+    assert_equal("Wookie hi!", context.invoke("hi", "Wookie"))
+  end
+
+  def test_add_item_in_outer_scope
+    @context['test'] = 'test'
+    @context.push
+    assert_equal('test', @context['test'])
+    @context.pop
+    assert_equal('test', @context['test'])
+  end
+
+  def test_add_item_in_inner_scope
+    @context.push
+    @context['test'] = 'test'
+    assert_equal('test', @context['test'])
+    @context.pop
+    assert_nil(@context['test'])
+  end
+
+  def test_hierachical_data
+    @context['hash'] = { "name" => 'tobi' }
+    assert_equal('tobi', @context['hash.name'])
+    assert_equal('tobi', @context['hash["name"]'])
+  end
+
+  def test_keywords
+    assert_equal(true, @context['true'])
+    assert_equal(false, @context['false'])
+  end
+
+  def test_digits
+    assert_equal(100, @context['100'])
+    assert_equal(100.00, @context['100.00'])
+  end
+
+  def test_strings
+    assert_equal("hello!", @context['"hello!"'])
+    assert_equal("hello!", @context["'hello!'"])
+  end
+
+  def test_merge
+    @context.merge("test" => "test")
+    assert_equal('test', @context['test'])
+    @context.merge("test" => "newvalue", "foo" => "bar")
+    assert_equal('newvalue', @context['test'])
+    assert_equal('bar', @context['foo'])
+  end
+
+  def test_array_notation
+    @context['test'] = [1, 2, 3, 4, 5]
+
+    assert_equal(1, @context['test[0]'])
+    assert_equal(2, @context['test[1]'])
+    assert_equal(3, @context['test[2]'])
+    assert_equal(4, @context['test[3]'])
+    assert_equal(5, @context['test[4]'])
+  end
+
+  def test_recoursive_array_notation
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
+
+    assert_equal(1, @context['test.test[0]'])
+
+    @context['test'] = [{ 'test' => 'worked' }]
+
+    assert_equal('worked', @context['test[0].test'])
+  end
+
+  def test_hash_to_array_transition
+    @context['colors'] = {
+      'Blue' => ['003366', '336699', '6699CC', '99CCFF'],
+      'Green' => ['003300', '336633', '669966', '99CC99'],
+      'Yellow' => ['CC9900', 'FFCC00', 'FFFF99', 'FFFFCC'],
+      'Red' => ['660000', '993333', 'CC6666', 'FF9999'],
+    }
+
+    assert_equal('003366', @context['colors.Blue[0]'])
+    assert_equal('FF9999', @context['colors.Red[3]'])
+  end
+
+  def test_try_first
+    @context['test'] = [1, 2, 3, 4, 5]
+
+    assert_equal(1, @context['test.first'])
+    assert_equal(5, @context['test.last'])
+
+    @context['test'] = { 'test' => [1, 2, 3, 4, 5] }
+
+    assert_equal(1, @context['test.test.first'])
+    assert_equal(5, @context['test.test.last'])
+
+    @context['test'] = [1]
+    assert_equal(1, @context['test.first'])
+    assert_equal(1, @context['test.last'])
+  end
+
+  def test_access_hashes_with_hash_notation
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+    @context['product']  = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
+
+    assert_equal(5, @context['products["count"]'])
+    assert_equal('deepsnow', @context['products["tags"][0]'])
+    assert_equal('deepsnow', @context['products["tags"].first'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"][1]["title"]'])
+    assert_equal('draft151cm', @context['product["variants"][0]["title"]'])
+    assert_equal('element151cm', @context['product["variants"].last["title"]'])
+  end
+
+  def test_access_variable_with_hash_notation
+    @context['foo'] = 'baz'
+    @context['bar'] = 'foo'
+
+    assert_equal('baz', @context['["foo"]'])
+    assert_equal('baz', @context['[bar]'])
+  end
+
+  def test_access_hashes_with_hash_access_variables
+    @context['var']      = 'tags'
+    @context['nested']   = { 'var' => 'tags' }
+    @context['products'] = { 'count' => 5, 'tags' => ['deepsnow', 'freestyle'] }
+
+    assert_equal('deepsnow', @context['products[var].first'])
+    assert_equal('freestyle', @context['products[nested.var].last'])
+  end
+
+  def test_hash_notation_only_for_hash_access
+    @context['array'] = [1, 2, 3, 4, 5]
+    @context['hash']  = { 'first' => 'Hello' }
+
+    assert_equal(1, @context['array.first'])
+    assert_nil(@context['array["first"]'])
+    assert_equal('Hello', @context['hash["first"]'])
+  end
+
+  def test_first_can_appear_in_middle_of_callchain
+    @context['product'] = { 'variants' => [{ 'title' => 'draft151cm' }, { 'title' => 'element151cm' }] }
+
+    assert_equal('draft151cm', @context['product.variants[0].title'])
+    assert_equal('element151cm', @context['product.variants[1].title'])
+    assert_equal('draft151cm', @context['product.variants.first.title'])
+    assert_equal('element151cm', @context['product.variants.last.title'])
+  end
+
+  def test_cents
+    @context.merge("cents" => HundredCentes.new)
+    assert_equal(100, @context['cents'])
+  end
+
+  def test_nested_cents
+    @context.merge("cents" => { 'amount' => HundredCentes.new })
+    assert_equal(100, @context['cents.amount'])
+
+    @context.merge("cents" => { 'cents' => { 'amount' => HundredCentes.new } })
+    assert_equal(100, @context['cents.cents.amount'])
+  end
+
+  def test_cents_through_drop
+    @context.merge("cents" => CentsDrop.new)
+    assert_equal(100, @context['cents.amount'])
+  end
+
+  def test_nested_cents_through_drop
+    @context.merge("vars" => { "cents" => CentsDrop.new })
+    assert_equal(100, @context['vars.cents.amount'])
+  end
+
+  def test_drop_methods_with_question_marks
+    @context.merge("cents" => CentsDrop.new)
+    assert(@context['cents.non_zero?'])
+  end
+
+  def test_context_from_within_drop
+    @context.merge("test" => '123', "vars" => ContextSensitiveDrop.new)
+    assert_equal('123', @context['vars.test'])
+  end
+
+  def test_nested_context_from_within_drop
+    @context.merge("test" => '123', "vars" => { "local" => ContextSensitiveDrop.new })
+    assert_equal('123', @context['vars.local.test'])
+  end
+
+  def test_ranges
+    @context.merge("test" => '5')
+    assert_equal((1..5), @context['(1..5)'])
+    assert_equal((1..5), @context['(1..test)'])
+    assert_equal((5..5), @context['(test..test)'])
+  end
+
+  def test_cents_through_drop_nestedly
+    @context.merge("cents" => { "cents" => CentsDrop.new })
+    assert_equal(100, @context['cents.cents.amount'])
+
+    @context.merge("cents" => { "cents" => { "cents" => CentsDrop.new } })
+    assert_equal(100, @context['cents.cents.cents.amount'])
+  end
+
+  def test_drop_with_variable_called_only_once
+    @context['counter'] = CounterDrop.new
+
+    assert_equal(1, @context['counter.count'])
+    assert_equal(2, @context['counter.count'])
+    assert_equal(3, @context['counter.count'])
+  end
+
+  def test_drop_with_key_called_only_once
+    @context['counter'] = CounterDrop.new
+
+    assert_equal(1, @context['counter["count"]'])
+    assert_equal(2, @context['counter["count"]'])
+    assert_equal(3, @context['counter["count"]'])
+  end
+
+  def test_proc_as_variable
+    @context['dynamic'] = proc { 'Hello' }
+
+    assert_equal('Hello', @context['dynamic'])
+  end
+
+  def test_lambda_as_variable
+    @context['dynamic'] = proc { 'Hello' }
+
+    assert_equal('Hello', @context['dynamic'])
+  end
+
+  def test_nested_lambda_as_variable
+    @context['dynamic'] = { "lambda" => proc { 'Hello' } }
+
+    assert_equal('Hello', @context['dynamic.lambda'])
+  end
+
+  def test_array_containing_lambda_as_variable
+    @context['dynamic'] = [1, 2, proc { 'Hello' }, 4, 5]
+
+    assert_equal('Hello', @context['dynamic[2]'])
+  end
+
+  def test_lambda_is_called_once
+    @global = 0
+
+    @context['callcount'] = proc {
+      @global += 1
+      @global.to_s
+    }
+
+    assert_equal('1', @context['callcount'])
+    assert_equal('1', @context['callcount'])
+    assert_equal('1', @context['callcount'])
+  end
+
+  def test_nested_lambda_is_called_once
+    @global = 0
+
+    @context['callcount'] = { "lambda" => proc {
+                                            @global += 1
+                                            @global.to_s
+                                          } }
+
+    assert_equal('1', @context['callcount.lambda'])
+    assert_equal('1', @context['callcount.lambda'])
+    assert_equal('1', @context['callcount.lambda'])
+  end
+
+  def test_lambda_in_array_is_called_once
+    @global = 0
+
+    @context['callcount'] = [1, 2, proc {
+                                     @global += 1
+                                     @global.to_s
+                                   }, 4, 5]
+
+    assert_equal('1', @context['callcount[2]'])
+    assert_equal('1', @context['callcount[2]'])
+    assert_equal('1', @context['callcount[2]'])
+  end
+
+  def test_access_to_context_from_proc
+    @context.registers[:magic] = 345392
+
+    @context['magic'] = proc { @context.registers[:magic] }
+
+    assert_equal(345392, @context['magic'])
+  end
+
+  def test_to_liquid_and_context_at_first_level
+    @context['category'] = Category.new("foobar")
+    assert_kind_of(CategoryDrop, @context['category'])
+    assert_equal(@context, @context['category'].context)
+  end
+
+  def test_interrupt_avoids_object_allocations
+    @context.interrupt? # ruby 3.0.0 allocates on the first call
+    assert_no_object_allocations do
+      @context.interrupt?
+    end
+  end
+
+  def test_context_initialization_with_a_proc_in_environment
+    contx = Context.new([test: ->(c) { c['poutine'] }], test: :foo)
+
+    assert(contx)
+    assert_nil(contx['poutine'])
+  end
+
+  def test_apply_global_filter
+    global_filter_proc = ->(output) { "#{output} filtered" }
+
+    context = Context.new
+    context.global_filter = global_filter_proc
+
+    assert_equal('hi filtered', context.apply_global_filter('hi'))
+  end
+
+  def test_static_environments_are_read_with_lower_priority_than_environments
+    context = Context.build(
+      static_environments: { 'shadowed' => 'static', 'unshadowed' => 'static' },
+      environments: { 'shadowed' => 'dynamic' }
+    )
+
+    assert_equal('dynamic', context['shadowed'])
+    assert_equal('static', context['unshadowed'])
+  end
+
+  def test_apply_global_filter_when_no_global_filter_exist
+    context = Context.new
+    assert_equal('hi', context.apply_global_filter('hi'))
+  end
+
+  def test_new_isolated_subcontext_does_not_inherit_variables
+    super_context = Context.new
+    super_context['my_variable'] = 'some value'
+    subcontext = super_context.new_isolated_subcontext
+
+    assert_nil(subcontext['my_variable'])
+  end
+
+  def test_new_isolated_subcontext_inherits_static_environment
+    super_context = Context.build(static_environments: { 'my_environment_value' => 'my value' })
+    subcontext    = super_context.new_isolated_subcontext
+
+    assert_equal('my value', subcontext['my_environment_value'])
+  end
+
+  def test_new_isolated_subcontext_inherits_resource_limits
+    resource_limits = ResourceLimits.new({})
+    super_context   = Context.new({}, {}, {}, false, resource_limits)
+    subcontext      = super_context.new_isolated_subcontext
+    assert_equal(resource_limits, subcontext.resource_limits)
+  end
+
+  def test_new_isolated_subcontext_inherits_exception_renderer
+    super_context = Context.new
+    super_context.exception_renderer = ->(_e) { 'my exception message' }
+    subcontext = super_context.new_isolated_subcontext
+    assert_equal('my exception message', subcontext.handle_error(Liquid::Error.new))
+  end
+
+  def test_new_isolated_subcontext_does_not_inherit_non_static_registers
+    registers = {
+      my_register: :my_value,
+    }
+    super_context = Context.new({}, {}, StaticRegisters.new(registers))
+    super_context.registers[:my_register] = :my_alt_value
+    subcontext                            = super_context.new_isolated_subcontext
+    assert_equal(:my_value, subcontext.registers[:my_register])
+  end
+
+  def test_new_isolated_subcontext_inherits_static_registers
+    super_context = Context.build(registers: { my_register: :my_value })
+    subcontext    = super_context.new_isolated_subcontext
+    assert_equal(:my_value, subcontext.registers[:my_register])
+  end
+
+  def test_new_isolated_subcontext_registers_do_not_pollute_context
+    super_context                      = Context.build(registers: { my_register: :my_value })
+    subcontext                         = super_context.new_isolated_subcontext
+    subcontext.registers[:my_register] = :my_alt_value
+    assert_equal(:my_value, super_context.registers[:my_register])
+  end
+
+  def test_new_isolated_subcontext_inherits_filters
+    my_filter = Module.new do
+      def my_filter(*)
+        'my filter result'
+      end
+    end
+
+    super_context = Context.new
+    super_context.add_filters([my_filter])
+    subcontext    = super_context.new_isolated_subcontext
+    template      = Template.parse('{{ 123 | my_filter }}')
+    assert_equal('my filter result', template.render(subcontext))
+  end
+
+  def test_disables_tag_specified
+    context = Context.new
+    context.with_disabled_tags(%w(foo bar)) do
+      assert_equal(true, context.tag_disabled?("foo"))
+      assert_equal(true, context.tag_disabled?("bar"))
+      assert_equal(false, context.tag_disabled?("unknown"))
+    end
+  end
+
+  def test_disables_nested_tags
+    context = Context.new
+    context.with_disabled_tags(["foo"]) do
+      context.with_disabled_tags(["foo"]) do
+        assert_equal(true, context.tag_disabled?("foo"))
+        assert_equal(false, context.tag_disabled?("bar"))
+      end
+      context.with_disabled_tags(["bar"]) do
+        assert_equal(true, context.tag_disabled?("foo"))
+        assert_equal(true, context.tag_disabled?("bar"))
+        context.with_disabled_tags(["foo"]) do
+          assert_equal(true, context.tag_disabled?("foo"))
+          assert_equal(true, context.tag_disabled?("bar"))
+        end
+      end
+      assert_equal(true, context.tag_disabled?("foo"))
+      assert_equal(false, context.tag_disabled?("bar"))
+    end
+  end
+
   def test_override_global_filter
     global = Module.new do
       def notice(output)
@@ -19,16 +605,30 @@ class ContextTest < Minitest::Test
     end
 
     with_global_filter(global) do
-      assert_equal 'Global test', Template.parse("{{'test' | notice }}").render!
-      assert_equal 'Local test', Template.parse("{{'test' | notice }}").render!({}, filters: [local])
+      assert_equal('Global test', Template.parse("{{'test' | notice }}").render!)
+      assert_equal('Local test', Template.parse("{{'test' | notice }}").render!({}, filters: [local]))
     end
   end
 
   def test_has_key_will_not_add_an_error_for_missing_keys
-    with_error_mode :strict do
+    with_error_mode(:strict) do
       context = Context.new
       context.key?('unknown')
-      assert_empty context.errors
+      assert_empty(context.errors)
     end
   end
-end
+
+  private
+
+  def assert_no_object_allocations
+    unless RUBY_ENGINE == 'ruby'
+      skip("stackprof needed to count object allocations")
+    end
+    require 'stackprof'
+
+    profile = StackProf.run(mode: :object) do
+      yield
+    end
+    assert_equal(0, profile[:samples])
+  end
+end # ContextTest

test/integration/drop_test.rb

@@ -49,10 +49,6 @@ class ProductDrop < Liquid::Drop
     ContextDrop.new
   end
 
-  def user_input
-    (+"foo").taint
-  end
-
   protected
 
   def callmenot
@@ -114,32 +110,6 @@ class DropsTest < Minitest::Test
     assert_equal('  ', tpl.render!('product' => ProductDrop.new))
   end
 
-  def test_rendering_raises_on_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      assert_raises TaintedError do
-        tpl.render!('product' => ProductDrop.new)
-      end
-    end
-  end
-
-  def test_rendering_warns_on_tainted_attr
-    with_taint_mode(:warn) do
-      tpl = Liquid::Template.parse('{{ product.user_input }}')
-      context = Context.new('product' => ProductDrop.new)
-      tpl.render!(context)
-      assert_equal [Liquid::TaintedError], context.warnings.map(&:class)
-      assert_equal "variable 'product.user_input' is tainted and was not escaped", context.warnings.first.to_s(false)
-    end
-  end
-
-  def test_rendering_doesnt_raise_on_escaped_tainted_attr
-    with_taint_mode(:error) do
-      tpl = Liquid::Template.parse('{{ product.user_input | escape }}')
-      tpl.render!('product' => ProductDrop.new)
-    end
-  end
-
   def test_drop_does_only_respond_to_whitelisted_methods
     assert_equal("", Liquid::Template.parse("{{ product.inspect }}").render!('product' => ProductDrop.new))
     assert_equal("", Liquid::Template.parse("{{ product.pretty_inspect }}").render!('product' => ProductDrop.new))
@@ -179,6 +149,11 @@ class DropsTest < Minitest::Test
     assert_equal(' carrot ', output)
   end
 
+  def test_context_drop_array_with_map
+    output = Liquid::Template.parse(' {{ contexts | map: "bar" }} ').render!('contexts' => [ContextDrop.new, ContextDrop.new], 'bar' => "carrot")
+    assert_equal(' carrotcarrot ', output)
+  end
+
   def test_nested_context_drop
     output = Liquid::Template.parse(' {{ product.context.foo }} ').render!('product' => ProductDrop.new, 'foo' => "monkey")
     assert_equal(' monkey ', output)
@@ -192,7 +167,7 @@ class DropsTest < Minitest::Test
   def test_object_methods_not_allowed
     [:dup, :clone, :singleton_class, :eval, :class_eval, :inspect].each do |method|
       output = Liquid::Template.parse(" {{ product.#{method} }} ").render!('product' => ProductDrop.new)
-      assert_equal '  ', output
+      assert_equal('  ', output)
     end
   end
 
@@ -235,28 +210,28 @@ class DropsTest < Minitest::Test
 
   def test_enumerable_drop_will_invoke_liquid_method_missing_for_clashing_method_names
     ["select", "each", "map", "cycle"].each do |method|
-      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
+      assert_equal(method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new))
+      assert_equal(method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new))
+      assert_equal(method.to_s, Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal(method.to_s, Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new))
     end
   end
 
   def test_some_enumerable_methods_still_get_invoked
     [:count, :max].each do |method|
-      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal "3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+      assert_equal("3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal("3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new))
+      assert_equal("3", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new))
+      assert_equal("3", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new))
     end
 
     assert_equal("yes", Liquid::Template.parse("{% if collection contains 3 %}yes{% endif %}").render!('collection' => RealEnumerableDrop.new))
 
     [:min, :first].each do |method|
-      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => RealEnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection.#{method}}}").render!('collection' => EnumerableDrop.new)
-      assert_equal "1", Liquid::Template.parse("{{collection[\"#{method}\"]}}").render!('collection' => EnumerableDrop.new)
+      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
 
@@ -274,7 +249,7 @@ class DropsTest < Minitest::Test
   end
 
   def test_invokable_methods
-    assert_equal(%w(to_liquid catchall user_input context texts).to_set, ProductDrop.invokable_methods)
+    assert_equal(%w(to_liquid catchall context texts).to_set, ProductDrop.invokable_methods)
     assert_equal(%w(to_liquid scopes_as_array loop_pos scopes).to_set, ContextDrop.invokable_methods)
     assert_equal(%w(to_liquid size max min first count).to_set, EnumerableDrop.invokable_methods)
     assert_equal(%w(to_liquid max min sort count first).to_set, RealEnumerableDrop.invokable_methods)

test/integration/error_handling_test.rb

@@ -193,7 +193,7 @@ class ErrorHandlingTest < Minitest::Test
 
   # Liquid should not catch Exceptions that are not subclasses of StandardError, like Interrupt and NoMemoryError
   def test_exceptions_propagate
-    assert_raises Exception do
+    assert_raises(Exception) do
       template = Liquid::Template.parse('{{ errors.exception }}')
       template.render('errors' => ErrorDrop.new)
     end
@@ -226,9 +226,9 @@ class ErrorHandlingTest < Minitest::Test
   end
 
   def test_exception_renderer_exposing_non_liquid_error
-    template = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
+    template   = Liquid::Template.parse('This is a runtime error: {{ errors.runtime_error }}', line_numbers: true)
     exceptions = []
-    handler = ->(e) {
+    handler    = ->(e) {
       exceptions << e
       e.cause
     }
@@ -252,12 +252,21 @@ class ErrorHandlingTest < Minitest::Test
 
     begin
       Liquid::Template.file_system = TestFileSystem.new
+
       template = Liquid::Template.parse("Argument error:\n{% include 'product' %}", line_numbers: true)
-      page = template.render('errors' => ErrorDrop.new)
+      page     = template.render('errors' => ErrorDrop.new)
     ensure
       Liquid::Template.file_system = old_file_system
     end
     assert_equal("Argument error:\nLiquid error (product line 1): argument error", page)
     assert_equal("product", template.errors.first.template_name)
   end
+
+  def test_bug_compatible_silencing_of_errors_in_blank_nodes
+    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}not blank{% assign x = 3 %}{% endif %}{{ x }}").render
+    assert_equal("Liquid error: comparison of Integer with String failed0", output)
+
+    output = Liquid::Template.parse("{% assign x = 0 %}{% if 1 < '2' %}{% assign x = 3 %}{% endif %}{{ x }}").render
+    assert_equal("0", output)
+  end
 end

test/integration/expression_test.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ExpressionTest < Minitest::Test
+  def test_keyword_literals
+    assert_equal(true, parse_and_eval("true"))
+    assert_equal(true, parse_and_eval(" true "))
+  end
+
+  def test_string
+    assert_equal("single quoted", parse_and_eval("'single quoted'"))
+    assert_equal("double quoted", parse_and_eval('"double quoted"'))
+    assert_equal("spaced", parse_and_eval(" 'spaced' "))
+    assert_equal("spaced2", parse_and_eval(' "spaced2" '))
+  end
+
+  def test_int
+    assert_equal(123, parse_and_eval("123"))
+    assert_equal(456, parse_and_eval(" 456 "))
+    assert_equal(12, parse_and_eval("012"))
+  end
+
+  def test_float
+    assert_equal(1.5, parse_and_eval("1.5"))
+    assert_equal(2.5, parse_and_eval(" 2.5 "))
+  end
+
+  def test_range
+    assert_equal(1..2, parse_and_eval("(1..2)"))
+    assert_equal(3..4, parse_and_eval(" ( 3 .. 4 ) "))
+  end
+
+  private
+
+  def parse_and_eval(markup, **assigns)
+    if Liquid::Template.error_mode == :strict
+      p = Liquid::Parser.new(markup)
+      markup = p.expression
+      p.consume(:end_of_string)
+    end
+    expression = Liquid::Expression.parse(markup)
+    context = Liquid::Context.new(assigns)
+    context.evaluate(expression)
+  end
+end

test/integration/filter_kwarg_test.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class FilterKwargTest < Minitest::Test
+  module KwargFilter
+    def html_tag(_tag, attributes)
+      attributes
+        .map { |key, value| "#{key}='#{value}'" }
+        .join(' ')
+    end
+  end
+
+  include Liquid
+
+  def test_can_parse_data_kwargs
+    with_global_filter(KwargFilter) do
+      assert_equal(
+        "data-src='src' data-widths='100, 200'",
+        Template.parse("{{ 'img' | html_tag: data-src: 'src', data-widths: '100, 200' }}").render(nil, nil)
+      )
+    end
+  end
+end

test/integration/filter_test.rb

@@ -72,10 +72,10 @@ class FiltersTest < Minitest::Test
   end
 
   def test_sort
-    @context['value'] = 3
+    @context['value']   = 3
     @context['numbers'] = [2, 1, 4, 3]
-    @context['words'] = ['expected', 'as', 'alphabetic']
-    @context['arrays'] = ['flower', 'are']
+    @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))
@@ -86,8 +86,8 @@ class FiltersTest < Minitest::Test
   end
 
   def test_sort_natural
-    @context['words'] = ['case', 'Assert', 'Insensitive']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => 'b' }, { 'a' => 'C' }]
+    @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
@@ -101,8 +101,8 @@ class FiltersTest < Minitest::Test
   end
 
   def test_compact
-    @context['words'] = ['a', nil, 'b', nil, 'c']
-    @context['hashes'] = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
+    @context['words']   = ['a', nil, 'b', nil, 'c']
+    @context['hashes']  = [{ 'a' => 'A' }, { 'a' => nil }, { 'a' => 'C' }]
     @context['objects'] = [TestObject.new('A'), TestObject.new(nil), TestObject.new('C')]
 
     # Test strings
@@ -141,9 +141,9 @@ class FiltersTest < Minitest::Test
 
   def test_filter_with_keyword_arguments
     @context['surname'] = 'john'
-    @context['input'] = 'hello %{first_name}, %{last_name}'
+    @context['input']   = 'hello %{first_name}, %{last_name}'
     @context.add_filters(SubstituteFilter)
-    output = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
+    output              = Template.parse(%({{ input | substitute: first_name: surname, last_name: 'doe' }})).render(@context)
     assert_equal('hello john, doe', output)
   end
 
@@ -153,6 +153,15 @@ class FiltersTest < Minitest::Test
     # tap still treated as a non-existent filter
     assert_equal("1000", Template.parse("{{var | tap}}").render!('var' => 1000))
   end
+
+  def test_liquid_argument_error
+    source = "{{ '' | size: 'too many args' }}"
+    exc = assert_raises(Liquid::ArgumentError) do
+      Template.parse(source).render!
+    end
+    assert_match(/\ALiquid error: wrong number of arguments /, exc.message)
+    assert_equal(exc.message, Template.parse(source).render)
+  end
 end
 
 class FiltersInTemplate < Minitest::Test
@@ -160,9 +169,9 @@ 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
 

test/integration/hash_ordering_test.rb

@@ -19,7 +19,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/output_test.rb

@@ -61,63 +61,63 @@ class OutputTest < Minitest::Test
   end
 
   def test_variable_piping
-    text = %( {{ car.gm | make_funny }} )
+    text     = %( {{ car.gm | make_funny }} )
     expected = %( LOL )
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_input
-    text = %( {{ car.gm | cite_funny }} )
+    text     = %( {{ car.gm | cite_funny }} )
     expected = %( LOL: bad )
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_args
-    text = %! {{ car.gm | add_smiley : ':-(' }} !
+    text     = %! {{ car.gm | add_smiley : ':-(' }} !
     expected = %| bad :-( |
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_no_args
-    text = %( {{ car.gm | add_smiley }} )
+    text     = %( {{ car.gm | add_smiley }} )
     expected = %| bad :-) |
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_multiple_variable_piping_with_args
-    text = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
+    text     = %! {{ car.gm | add_smiley : ':-(' | add_smiley : ':-('}} !
     expected = %| bad :-( :-( |
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_multiple_args
-    text = %( {{ car.gm | add_tag : 'span', 'bar'}} )
+    text     = %( {{ car.gm | add_tag : 'span', 'bar'}} )
     expected = %( <span id="bar">bad</span> )
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_variable_piping_with_variable_args
-    text = %( {{ car.gm | add_tag : 'span', car.bmw}} )
+    text     = %( {{ car.gm | add_tag : 'span', car.bmw}} )
     expected = %( <span id="good">bad</span> )
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_multiple_pipings
-    text = %( {{ best_cars | cite_funny | paragraph }} )
+    text     = %( {{ best_cars | cite_funny | paragraph }} )
     expected = %( <p>LOL: bmw</p> )
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))
   end
 
   def test_link_to
-    text = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
+    text     = %( {{ 'Typo' | link_to: 'http://typo.leetsoft.com' }} )
     expected = %( <a href="http://typo.leetsoft.com">Typo</a> )
 
     assert_equal(expected, Template.parse(text).render!(@assigns, filters: [FunnyFilter]))

test/integration/parsing_quirks_test.rb

@@ -32,7 +32,7 @@ class ParsingQuirksTest < Minitest::Test
     assert(Template.parse("{{test}}"))
 
     with_error_mode(:lax) do
-      assert Template.parse("{{|test}}")
+      assert(Template.parse("{{|test}}"))
     end
 
     with_error_mode(:strict) do
@@ -72,7 +72,7 @@ class ParsingQuirksTest < Minitest::Test
   def test_meaningless_parens_lax
     with_error_mode(:lax) do
       assigns = { 'b' => 'bar', 'c' => 'baz' }
-      markup = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
+      markup  = "a == 'foo' or (b == 'bar' and c == 'baz') or false"
       assert_template_result(' YES ', "{% if #{markup} %} YES {% endif %}", assigns)
     end
   end
@@ -118,6 +118,16 @@ class ParsingQuirksTest < Minitest::Test
     end
   end
 
+  def test_blank_variable_markup
+    assert_template_result('', "{{}}")
+  end
+
+  def test_lookup_on_var_with_literal_name
+    assigns = { "blank" => { "x" => "result" } }
+    assert_template_result('result', "{{ blank.x }}", assigns)
+    assert_template_result('result', "{{ blank['x'] }}", assigns)
+  end
+
   def test_contains_in_id
     assert_template_result(' YES ', '{% if containsallshipments == true %} YES {% endif %}', 'containsallshipments' => true)
   end

test/integration/profiler_test.rb

@@ -2,7 +2,28 @@
 
 require 'test_helper'
 
-class RenderProfilingTest < Minitest::Test
+class ProfilerTest < Minitest::Test
+  class TestDrop < Liquid::Drop
+    def initialize(value)
+      super()
+      @value = value
+    end
+
+    def to_s
+      artificial_execution_time
+
+      @value
+    end
+
+    private
+
+    # Monotonic clock precision fluctuate based on the operating system
+    # By introducing a small sleep we ensure ourselves to register a non zero unit of time
+    def artificial_execution_time
+      sleep(Process.clock_getres(Process::CLOCK_MONOTONIC))
+    end
+  end
+
   include Liquid
 
   class ProfilingFileSystem
@@ -62,6 +83,17 @@ class RenderProfilingTest < Minitest::Test
     assert_equal(2, included_children[1].line_number)
   end
 
+  def test_profiling_render_tag
+    t = Template.parse("{% render 'a_template' %}", profile: true)
+    t.render!
+
+    render_children = t.profiler[0].children
+    render_children.each do |timing|
+      assert_equal('a_template', timing.partial)
+    end
+    assert_equal([1, 2], render_children.map(&:line_number))
+  end
+
   def test_profiling_times_the_rendering_of_tokens
     t = Template.parse("{% include 'a_template' %}", profile: true)
     t.render!
@@ -77,6 +109,37 @@ class RenderProfilingTest < Minitest::Test
     assert(t.profiler.total_render_time >= 0, "Total render time was not calculated")
   end
 
+  class SleepTag < Liquid::Tag
+    def initialize(tag_name, markup, parse_context)
+      super
+      @duration = Float(markup)
+    end
+
+    def render_to_output_buffer(_context, _output)
+      sleep(@duration)
+    end
+  end
+
+  def test_profiling_multiple_renders
+    with_custom_tag('sleep', SleepTag) do
+      context = Liquid::Context.new
+      t = Liquid::Template.parse("{% sleep 0.001 %}", profile: true)
+      context.template_name = 'index'
+      t.render!(context)
+      context.template_name = 'layout'
+      first_render_time = context.profiler.total_time
+      t.render!(context)
+
+      profiler = context.profiler
+      children = profiler.children
+      assert_operator(first_render_time, :>=, 0.001)
+      assert_operator(profiler.total_time, :>=, 0.001 + first_render_time)
+      assert_equal(["index", "layout"], children.map(&:template_name))
+      assert_equal([nil, nil], children.map(&:code))
+      assert_equal(profiler.total_time, children.map(&:total_time).reduce(&:+))
+    end
+  end
+
   def test_profiling_uses_include_to_mark_children
     t = Template.parse("{{ 'a string' | upcase }}\n{% include 'a_template' %}", profile: true)
     t.render!
@@ -91,7 +154,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 +164,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 +179,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
 
@@ -153,4 +216,25 @@ class RenderProfilingTest < Minitest::Test
     # Will profile each invocation of the for block
     assert_equal(2, t.profiler[0].children.length)
   end
+
+  def test_profiling_supports_self_time
+    t = Template.parse("{% for item in collection %} {{ item }} {% endfor %}", profile: true)
+    collection = [
+      TestDrop.new("one"),
+      TestDrop.new("two"),
+    ]
+    output = t.render!("collection" => collection)
+    assert_equal(" one  two ", output)
+
+    leaf = t.profiler[0].children[0]
+    assert_operator(leaf.self_time, :>, 0.0)
+  end
+
+  def test_profiling_supports_total_time
+    t = Template.parse("{% if true %} {{ test }} {% endif %}", profile: true)
+    output = t.render!("test" => TestDrop.new("one"))
+    assert_equal(" one ", output)
+
+    assert_operator(t.profiler[0].total_time, :>, 0.0)
+  end
 end

test/integration/registers/disabled_tags_test.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-require 'test_helper'
-
-class DisabledTagsTest < Minitest::Test
-  include Liquid
-
-  class DisableRaw < Block
-    disable_tags "raw"
-  end
-
-  class DisableRawEcho < Block
-    disable_tags "raw", "echo"
-  end
-
-  def test_disables_raw
-    with_custom_tag('disable', DisableRaw) do
-      assert_template_result 'raw usage is not allowed in this contextfoo', '{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}'
-    end
-  end
-
-  def test_disables_echo_and_raw
-    with_custom_tag('disable', DisableRawEcho) do
-      assert_template_result 'raw usage is not allowed in this contextecho usage is not allowed in this context', '{% disable %}{% raw %}Foobar{% endraw %}{% echo "foo" %}{% enddisable %}'
-    end
-  end
-end